@sanity/document-internationalization 3.2.0 → 3.2.1

package/dist/index.js

@@ -1,6 +1,21 @@
 "use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty, __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp.call(b, prop) && __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b))
+      __propIsEnum.call(b, prop) && __defNormalProp(a, prop, b[prop]);
+  return a;
+};
 Object.defineProperty(exports, "__esModule", { value: !0 });
-var jsxRuntime = require("react/jsx-runtime"), icons = require("@sanity/icons"), ui = require("@sanity/ui"), react = require("react"), sanity = require("sanity"), sanityPluginUtils = require("sanity-plugin-utils"), uuid = require("@sanity/uuid"), router = require("sanity/router"), structure = require("sanity/structure"), mutator = require("@sanity/mutator"), styledComponents = require("styled-components"), sanityPluginInternationalizedArray = require("sanity-plugin-internationalized-array");
+var jsxRuntime = require("react/jsx-runtime"), icons = require("@sanity/icons"), ui = require("@sanity/ui"), react = require("react"), sanity = require("sanity"), sanityPluginUtils = require("sanity-plugin-utils"), uuid = require("@sanity/uuid"), router = require("sanity/router"), structure = require("sanity/structure"), require$$0 = require("tty"), require$$1 = require("util"), styledComponents = require("styled-components"), sanityPluginInternationalizedArray = require("sanity-plugin-internationalized-array");
+function _interopDefaultCompat(e) {
+  return e && typeof e == "object" && "default" in e ? e : { default: e };
+}
+var require$$0__default = /* @__PURE__ */ _interopDefaultCompat(require$$0), require$$1__default = /* @__PURE__ */ _interopDefaultCompat(require$$1);
 function DocumentPreview(props) {
   const schemaType = sanity.useSchema().get(props.type);
   return schemaType ? /* @__PURE__ */ jsxRuntime.jsx(sanity.Preview, { value: props.value, schemaType }) : /* @__PURE__ */ jsxRuntime.jsx(sanityPluginUtils.Feedback, { tone: "critical", title: "Schema type not found" });
@@ -132,7 +147,16 @@ function query$1(fn, keys = null, preload = !1, config2 = {}) {
   if (globalCache.push(entry), !preload)
     throw entry.promise;
 }
-const suspend = (fn, keys, config2) => query$1(fn, keys, !1, config2), DocumentInternationalizationContext = react.createContext(DEFAULT_CONFIG);
+const suspend = (fn, keys, config2) => query$1(fn, keys, !1, config2);
+var __defProp$i = Object.defineProperty, __defProps$2 = Object.defineProperties, __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$3 = Object.getOwnPropertySymbols, __hasOwnProp$3 = Object.prototype.hasOwnProperty, __propIsEnum$3 = Object.prototype.propertyIsEnumerable, __defNormalProp$i = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$3.call(b, prop) && __defNormalProp$i(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b))
+      __propIsEnum$3.call(b, prop) && __defNormalProp$i(a, prop, b[prop]);
+  return a;
+}, __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+const DocumentInternationalizationContext = react.createContext(DEFAULT_CONFIG);
 function useDocumentInternationalizationContext() {
   return react.useContext(DocumentInternationalizationContext);
 }
@@ -144,7 +168,7 @@ function DocumentInternationalizationProvider(props) {
   return /* @__PURE__ */ jsxRuntime.jsx(
     DocumentInternationalizationContext.Provider,
     {
-      value: { ...pluginConfig, supportedLanguages },
+      value: __spreadProps$2(__spreadValues$3({}, pluginConfig), { supportedLanguages }),
       children: props.renderDefault(props)
     }
   );
@@ -260,7 +284,7 @@ function __spreadArray(to, from, pack) {
       (ar || !(i in from)) && (ar || (ar = Array.prototype.slice.call(from, 0, i)), ar[i] = from[i]);
   return to.concat(ar || Array.prototype.slice.call(from));
 }
-function isFunction(value) {
+function isFunction$2(value) {
   return typeof value == "function";
 }
 function createErrorClass(createImpl) {
@@ -313,7 +337,7 @@ var Subscription = function() {
         else
           _parentage.remove(this);
       var initialFinalizer = this.initialTeardown;
-      if (isFunction(initialFinalizer))
+      if (isFunction$2(initialFinalizer))
         try {
           initialFinalizer();
         } catch (e) {
@@ -376,10 +400,10 @@ var Subscription = function() {
   }(), Subscription2;
 }();
 function isSubscription(value) {
-  return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+  return value instanceof Subscription || value && "closed" in value && isFunction$2(value.remove) && isFunction$2(value.add) && isFunction$2(value.unsubscribe);
 }
 function execFinalizer(finalizer) {
-  isFunction(finalizer) ? finalizer() : finalizer.unsubscribe();
+  isFunction$2(finalizer) ? finalizer() : finalizer.unsubscribe();
 }
 var config = {
   onUnhandledError: null,
@@ -475,7 +499,7 @@ var ConsumerObserver = function() {
   __extends(SafeSubscriber2, _super);
   function SafeSubscriber2(observerOrNext, error, complete) {
     var _this = _super.call(this) || this, partialObserver;
-    if (isFunction(observerOrNext) || !observerOrNext)
+    if (isFunction$2(observerOrNext) || !observerOrNext)
       partialObserver = {
         next: observerOrNext != null ? observerOrNext : void 0,
         error: error != null ? error : void 0,
@@ -508,7 +532,7 @@ var EMPTY_OBSERVER = {
   complete: noop
 };
 function hasLift(source) {
-  return isFunction(source == null ? void 0 : source.lift);
+  return isFunction$2(source == null ? void 0 : source.lift);
 }
 function operate(init) {
   return function(source) {
@@ -567,7 +591,6 @@ var OperatorSubscriber = function(_super) {
   };
 });
 function firstValueFrom(source, config2) {
-  var hasConfig = typeof config2 == "object";
   return new Promise(function(resolve, reject) {
     var subscriber = new SafeSubscriber({
       next: function(value) {
@@ -575,7 +598,7 @@ function firstValueFrom(source, config2) {
       },
       error: reject,
       complete: function() {
-        hasConfig ? resolve(config2.defaultValue) : reject(new EmptyError());
+        reject(new EmptyError());
       }
     });
     source.subscribe(subscriber);
@@ -745,17 +768,23 @@ function useOpenInNewPane(id, type) {
     routerContext.navigateUrl({ path: href });
   }, [id, type, routerContext, routerPanesState, groupIndex]);
 }
+var __defProp$2 = Object.defineProperty, __getOwnPropSymbols$2 = Object.getOwnPropertySymbols, __hasOwnProp$2 = Object.prototype.hasOwnProperty, __propIsEnum$2 = Object.prototype.propertyIsEnumerable, __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b))
+      __propIsEnum$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
+  return a;
+};
 function createReference(key, ref, type, strengthenOnPublish = !0) {
   return {
     _key: key,
     _type: "internationalizedArrayReferenceValue",
-    value: {
+    value: __spreadValues$2({
       _type: "reference",
       _ref: ref,
-      _weak: !0,
-      // If the user has configured weakReferences, we won't want to strengthen them
-      ...strengthenOnPublish ? { _strengthenOnPublish: { type } } : {}
-    }
+      _weak: !0
+    }, strengthenOnPublish ? { _strengthenOnPublish: { type } } : {})
   };
 }
 function LanguageManage(props) {
@@ -814,152 +843,2946 @@ function LanguageManage(props) {
     }
   );
 }
-function removeExcludedPaths(doc, schemaType) {
-  if (!sanity.isDocumentSchemaType(schemaType) || !doc)
-    return doc;
-  const pathsToExclude = extractPaths(doc, schemaType, []).filter(
-    (field) => {
-      var _a, _b, _c;
-      return ((_c = (_b = (_a = field.schemaType) == null ? void 0 : _a.options) == null ? void 0 : _b.documentInternationalization) == null ? void 0 : _c.exclude) === !0;
+var commonjsGlobal = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x.default : x;
+}
+function listCacheClear$1() {
+  this.__data__ = [], this.size = 0;
+}
+var _listCacheClear = listCacheClear$1;
+function eq$1(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_1 = eq$1, eq = eq_1;
+function assocIndexOf$4(array, key) {
+  for (var length = array.length; length--; )
+    if (eq(array[length][0], key))
+      return length;
+  return -1;
+}
+var _assocIndexOf = assocIndexOf$4, assocIndexOf$3 = _assocIndexOf, arrayProto = Array.prototype, splice = arrayProto.splice;
+function listCacheDelete$1(key) {
+  var data = this.__data__, index = assocIndexOf$3(data, key);
+  if (index < 0)
+    return !1;
+  var lastIndex = data.length - 1;
+  return index == lastIndex ? data.pop() : splice.call(data, index, 1), --this.size, !0;
+}
+var _listCacheDelete = listCacheDelete$1, assocIndexOf$2 = _assocIndexOf;
+function listCacheGet$1(key) {
+  var data = this.__data__, index = assocIndexOf$2(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+var _listCacheGet = listCacheGet$1, assocIndexOf$1 = _assocIndexOf;
+function listCacheHas$1(key) {
+  return assocIndexOf$1(this.__data__, key) > -1;
+}
+var _listCacheHas = listCacheHas$1, assocIndexOf = _assocIndexOf;
+function listCacheSet$1(key, value) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  return index < 0 ? (++this.size, data.push([key, value])) : data[index][1] = value, this;
+}
+var _listCacheSet = listCacheSet$1, listCacheClear = _listCacheClear, listCacheDelete = _listCacheDelete, listCacheGet = _listCacheGet, listCacheHas = _listCacheHas, listCacheSet = _listCacheSet;
+function ListCache$4(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  for (this.clear(); ++index < length; ) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache$4.prototype.clear = listCacheClear;
+ListCache$4.prototype.delete = listCacheDelete;
+ListCache$4.prototype.get = listCacheGet;
+ListCache$4.prototype.has = listCacheHas;
+ListCache$4.prototype.set = listCacheSet;
+var _ListCache = ListCache$4, ListCache$3 = _ListCache;
+function stackClear$1() {
+  this.__data__ = new ListCache$3(), this.size = 0;
+}
+var _stackClear = stackClear$1;
+function stackDelete$1(key) {
+  var data = this.__data__, result = data.delete(key);
+  return this.size = data.size, result;
+}
+var _stackDelete = stackDelete$1;
+function stackGet$1(key) {
+  return this.__data__.get(key);
+}
+var _stackGet = stackGet$1;
+function stackHas$1(key) {
+  return this.__data__.has(key);
+}
+var _stackHas = stackHas$1, freeGlobal$1 = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal, _freeGlobal = freeGlobal$1, freeGlobal = _freeGlobal, freeSelf = typeof self == "object" && self && self.Object === Object && self, root$7 = freeGlobal || freeSelf || Function("return this")(), _root = root$7, root$6 = _root, Symbol$4 = root$6.Symbol, _Symbol = Symbol$4, Symbol$3 = _Symbol, objectProto$5 = Object.prototype, hasOwnProperty$4 = objectProto$5.hasOwnProperty, nativeObjectToString$1 = objectProto$5.toString, symToStringTag$1 = Symbol$3 ? Symbol$3.toStringTag : void 0;
+function getRawTag$1(value) {
+  var isOwn = hasOwnProperty$4.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 _getRawTag = getRawTag$1, objectProto$4 = Object.prototype, nativeObjectToString = objectProto$4.toString;
+function objectToString$1(value) {
+  return nativeObjectToString.call(value);
+}
+var _objectToString = objectToString$1, Symbol$2 = _Symbol, getRawTag = _getRawTag, objectToString = _objectToString, nullTag = "[object Null]", undefinedTag = "[object Undefined]", symToStringTag = Symbol$2 ? Symbol$2.toStringTag : void 0;
+function baseGetTag$4(value) {
+  return value == null ? value === void 0 ? undefinedTag : nullTag : symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+var _baseGetTag = baseGetTag$4;
+function isObject$2(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_1 = isObject$2, baseGetTag$3 = _baseGetTag, isObject$1 = isObject_1, asyncTag = "[object AsyncFunction]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction$1(value) {
+  if (!isObject$1(value))
+    return !1;
+  var tag = baseGetTag$3(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_1 = isFunction$1, root$5 = _root, coreJsData$1 = root$5["__core-js_shared__"], _coreJsData = coreJsData$1, coreJsData = _coreJsData, maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked$1(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var _isMasked = isMasked$1, funcProto$1 = Function.prototype, funcToString$1 = funcProto$1.toString;
+function toSource$2(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {
     }
-  ).map((field) => sanity.pathToString(field.path));
-  return new mutator.Mutation({
-    mutations: [
-      {
-        patch: {
-          id: doc._id,
-          unset: pathsToExclude
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var _toSource = toSource$2, isFunction = isFunction_1, isMasked = _isMasked, isObject = isObject_1, toSource$1 = _toSource, reRegExpChar = /[\\^$.*+?()[\]{}|]/g, reIsHostCtor = /^\[object .+?Constructor\]$/, funcProto = Function.prototype, objectProto$3 = Object.prototype, funcToString = funcProto.toString, hasOwnProperty$3 = objectProto$3.hasOwnProperty, reIsNative = RegExp(
+  "^" + funcToString.call(hasOwnProperty$3).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative$1(value) {
+  if (!isObject(value) || isMasked(value))
+    return !1;
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource$1(value));
+}
+var _baseIsNative = baseIsNative$1;
+function getValue$1(object, key) {
+  return object == null ? void 0 : object[key];
+}
+var _getValue = getValue$1, baseIsNative = _baseIsNative, getValue = _getValue;
+function getNative$6(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var _getNative = getNative$6, getNative$5 = _getNative, root$4 = _root, Map$4 = getNative$5(root$4, "Map"), _Map = Map$4, getNative$4 = _getNative, nativeCreate$4 = getNative$4(Object, "create"), _nativeCreate = nativeCreate$4, nativeCreate$3 = _nativeCreate;
+function hashClear$1() {
+  this.__data__ = nativeCreate$3 ? nativeCreate$3(null) : {}, this.size = 0;
+}
+var _hashClear = hashClear$1;
+function hashDelete$1(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  return this.size -= result ? 1 : 0, result;
+}
+var _hashDelete = hashDelete$1, nativeCreate$2 = _nativeCreate, HASH_UNDEFINED$2 = "__lodash_hash_undefined__", objectProto$2 = Object.prototype, hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+function hashGet$1(key) {
+  var data = this.__data__;
+  if (nativeCreate$2) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$2 ? void 0 : result;
+  }
+  return hasOwnProperty$2.call(data, key) ? data[key] : void 0;
+}
+var _hashGet = hashGet$1, nativeCreate$1 = _nativeCreate, objectProto$1 = Object.prototype, hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+function hashHas$1(key) {
+  var data = this.__data__;
+  return nativeCreate$1 ? data[key] !== void 0 : hasOwnProperty$1.call(data, key);
+}
+var _hashHas = hashHas$1, nativeCreate = _nativeCreate, HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+function hashSet$1(key, value) {
+  var data = this.__data__;
+  return this.size += this.has(key) ? 0 : 1, data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED$1 : value, this;
+}
+var _hashSet = hashSet$1, hashClear = _hashClear, hashDelete = _hashDelete, hashGet = _hashGet, hashHas = _hashHas, hashSet = _hashSet;
+function Hash$1(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  for (this.clear(); ++index < length; ) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash$1.prototype.clear = hashClear;
+Hash$1.prototype.delete = hashDelete;
+Hash$1.prototype.get = hashGet;
+Hash$1.prototype.has = hashHas;
+Hash$1.prototype.set = hashSet;
+var _Hash = Hash$1, Hash = _Hash, ListCache$2 = _ListCache, Map$3 = _Map;
+function mapCacheClear$1() {
+  this.size = 0, this.__data__ = {
+    hash: new Hash(),
+    map: new (Map$3 || ListCache$2)(),
+    string: new Hash()
+  };
+}
+var _mapCacheClear = mapCacheClear$1;
+function isKeyable$1(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var _isKeyable = isKeyable$1, isKeyable = _isKeyable;
+function getMapData$4(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var _getMapData = getMapData$4, getMapData$3 = _getMapData;
+function mapCacheDelete$1(key) {
+  var result = getMapData$3(this, key).delete(key);
+  return this.size -= result ? 1 : 0, result;
+}
+var _mapCacheDelete = mapCacheDelete$1, getMapData$2 = _getMapData;
+function mapCacheGet$1(key) {
+  return getMapData$2(this, key).get(key);
+}
+var _mapCacheGet = mapCacheGet$1, getMapData$1 = _getMapData;
+function mapCacheHas$1(key) {
+  return getMapData$1(this, key).has(key);
+}
+var _mapCacheHas = mapCacheHas$1, getMapData = _getMapData;
+function mapCacheSet$1(key, value) {
+  var data = getMapData(this, key), size = data.size;
+  return data.set(key, value), this.size += data.size == size ? 0 : 1, this;
+}
+var _mapCacheSet = mapCacheSet$1, mapCacheClear = _mapCacheClear, mapCacheDelete = _mapCacheDelete, mapCacheGet = _mapCacheGet, mapCacheHas = _mapCacheHas, mapCacheSet = _mapCacheSet;
+function MapCache$2(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  for (this.clear(); ++index < length; ) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache$2.prototype.clear = mapCacheClear;
+MapCache$2.prototype.delete = mapCacheDelete;
+MapCache$2.prototype.get = mapCacheGet;
+MapCache$2.prototype.has = mapCacheHas;
+MapCache$2.prototype.set = mapCacheSet;
+var _MapCache = MapCache$2, ListCache$1 = _ListCache, Map$2 = _Map, MapCache$1 = _MapCache, LARGE_ARRAY_SIZE = 200;
+function stackSet$1(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache$1) {
+    var pairs = data.__data__;
+    if (!Map$2 || pairs.length < LARGE_ARRAY_SIZE - 1)
+      return pairs.push([key, value]), this.size = ++data.size, this;
+    data = this.__data__ = new MapCache$1(pairs);
+  }
+  return data.set(key, value), this.size = data.size, this;
+}
+var _stackSet = stackSet$1, ListCache = _ListCache, stackClear = _stackClear, stackDelete = _stackDelete, stackGet = _stackGet, stackHas = _stackHas, stackSet = _stackSet;
+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 HASH_UNDEFINED = "__lodash_hash_undefined__";
+function setCacheAdd$1(value) {
+  return this.__data__.set(value, HASH_UNDEFINED), this;
+}
+var _setCacheAdd = setCacheAdd$1;
+function setCacheHas$1(value) {
+  return this.__data__.has(value);
+}
+var _setCacheHas = setCacheHas$1, MapCache = _MapCache, setCacheAdd = _setCacheAdd, setCacheHas = _setCacheHas;
+function SetCache(values) {
+  var index = -1, length = values == null ? 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;
+function arrayPush$1(array, values) {
+  for (var index = -1, length = values.length, offset = array.length; ++index < length; )
+    array[offset + index] = values[index];
+  return array;
+}
+var _arrayPush = arrayPush$1, isArray$1 = Array.isArray, isArray_1 = isArray$1;
+function isObjectLike$3(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_1 = isObjectLike$3, baseGetTag$2 = _baseGetTag, isObjectLike$2 = isObjectLike_1, argsTag = "[object Arguments]";
+function baseIsArguments$1(value) {
+  return isObjectLike$2(value) && baseGetTag$2(value) == argsTag;
+}
+var _baseIsArguments = baseIsArguments$1, baseIsArguments = _baseIsArguments, isObjectLike$1 = isObjectLike_1, objectProto = Object.prototype, hasOwnProperty = objectProto.hasOwnProperty, propertyIsEnumerable = objectProto.propertyIsEnumerable, isArguments$1 = baseIsArguments(/* @__PURE__ */ function() {
+  return arguments;
+}()) ? baseIsArguments : function(value) {
+  return isObjectLike$1(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+}, isArguments_1 = isArguments$1, isBuffer = { exports: {} };
+function stubFalse() {
+  return !1;
+}
+var stubFalse_1 = stubFalse;
+(function(module2, exports2) {
+  var root2 = _root, stubFalse2 = stubFalse_1, freeExports = exports2 && !exports2.nodeType && exports2, freeModule = freeExports && !0 && module2 && !module2.nodeType && module2, moduleExports = freeModule && freeModule.exports === freeExports, Buffer2 = moduleExports ? root2.Buffer : void 0, nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0, isBuffer2 = nativeIsBuffer || stubFalse2;
+  module2.exports = isBuffer2;
+})(isBuffer, isBuffer.exports);
+var _nodeUtil = { exports: {} };
+(function(module2, exports2) {
+  var freeGlobal2 = _freeGlobal, freeExports = exports2 && !exports2.nodeType && exports2, freeModule = freeExports && !0 && module2 && !module2.nodeType && module2, moduleExports = freeModule && freeModule.exports === freeExports, freeProcess = moduleExports && freeGlobal2.process, nodeUtil = function() {
+    try {
+      var types = freeModule && freeModule.require && freeModule.require("util").types;
+      return types || freeProcess && freeProcess.binding && freeProcess.binding("util");
+    } catch (e) {
+    }
+  }();
+  module2.exports = nodeUtil;
+})(_nodeUtil, _nodeUtil.exports);
+var getNative$3 = _getNative, root$3 = _root, DataView$1 = getNative$3(root$3, "DataView"), _DataView = DataView$1, getNative$2 = _getNative, root$2 = _root, Promise$2 = getNative$2(root$2, "Promise"), _Promise = Promise$2, getNative$1 = _getNative, root$1 = _root, Set$2 = getNative$1(root$1, "Set"), _Set = Set$2, getNative = _getNative, root = _root, WeakMap$1 = getNative(root, "WeakMap"), _WeakMap = WeakMap$1, DataView = _DataView, Map$1 = _Map, Promise$1 = _Promise, Set$1 = _Set, WeakMap = _WeakMap, baseGetTag$1 = _baseGetTag, toSource = _toSource, mapTag = "[object Map]", objectTag = "[object Object]", promiseTag = "[object Promise]", setTag = "[object Set]", weakMapTag = "[object WeakMap]", dataViewTag = "[object DataView]", dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$1), weakMapCtorString = toSource(WeakMap), getTag = baseGetTag$1;
+(DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map$1 && getTag(new Map$1()) != mapTag || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set$1 && getTag(new Set$1()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) && (getTag = function(value) {
+  var result = baseGetTag$1(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+  if (ctorString)
+    switch (ctorString) {
+      case dataViewCtorString:
+        return dataViewTag;
+      case mapCtorString:
+        return mapTag;
+      case promiseCtorString:
+        return promiseTag;
+      case setCtorString:
+        return setTag;
+      case weakMapCtorString:
+        return weakMapTag;
+    }
+  return result;
+});
+var src = { exports: {} }, browser$1 = { exports: {} }, ms, hasRequiredMs;
+function requireMs() {
+  if (hasRequiredMs)
+    return ms;
+  hasRequiredMs = 1;
+  var s = 1e3, m = s * 60, h = m * 60, d = h * 24, w = d * 7, y = d * 365.25;
+  ms = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0)
+      return parse2(val);
+    if (type === "number" && isFinite(val))
+      return options.long ? fmtLong(val) : fmtShort(val);
+    throw new Error(
+      "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+    );
+  };
+  function parse2(str) {
+    if (str = String(str), !(str.length > 100)) {
+      var match2 = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (match2) {
+        var n = parseFloat(match2[1]), type = (match2[2] || "ms").toLowerCase();
+        switch (type) {
+          case "years":
+          case "year":
+          case "yrs":
+          case "yr":
+          case "y":
+            return n * y;
+          case "weeks":
+          case "week":
+          case "w":
+            return n * w;
+          case "days":
+          case "day":
+          case "d":
+            return n * d;
+          case "hours":
+          case "hour":
+          case "hrs":
+          case "hr":
+          case "h":
+            return n * h;
+          case "minutes":
+          case "minute":
+          case "mins":
+          case "min":
+          case "m":
+            return n * m;
+          case "seconds":
+          case "second":
+          case "secs":
+          case "sec":
+          case "s":
+            return n * s;
+          case "milliseconds":
+          case "millisecond":
+          case "msecs":
+          case "msec":
+          case "ms":
+            return n;
+          default:
+            return;
         }
       }
-    ]
-  }).apply(doc);
+    }
+  }
+  function fmtShort(ms2) {
+    var msAbs = Math.abs(ms2);
+    return msAbs >= d ? Math.round(ms2 / d) + "d" : msAbs >= h ? Math.round(ms2 / h) + "h" : msAbs >= m ? Math.round(ms2 / m) + "m" : msAbs >= s ? Math.round(ms2 / s) + "s" : ms2 + "ms";
+  }
+  function fmtLong(ms2) {
+    var msAbs = Math.abs(ms2);
+    return msAbs >= d ? plural(ms2, msAbs, d, "day") : msAbs >= h ? plural(ms2, msAbs, h, "hour") : msAbs >= m ? plural(ms2, msAbs, m, "minute") : msAbs >= s ? plural(ms2, msAbs, s, "second") : ms2 + " ms";
+  }
+  function plural(ms2, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms2 / n) + " " + name + (isPlural ? "s" : "");
+  }
+  return ms;
 }
-function extractPaths(doc, schemaType, path) {
-  return schemaType.fields.reduce((acc, field) => {
-    var _a, _b;
-    const fieldPath = [...path, field.name], fieldSchema = field.type, { value } = (_a = mutator.extractWithPath(sanity.pathToString(fieldPath), doc)[0]) != null ? _a : {};
-    if (!value)
-      return acc;
-    const thisFieldWithPath = {
-      path: fieldPath,
-      name: field.name,
-      schemaType: fieldSchema,
-      value
-    };
-    if (fieldSchema.jsonType === "object") {
-      const innerFields = extractPaths(doc, fieldSchema, fieldPath);
-      return [...acc, thisFieldWithPath, ...innerFields];
-    } else if (fieldSchema.jsonType === "array" && fieldSchema.of.length && fieldSchema.of.some((item) => "fields" in item)) {
-      const { value: arrayValue } = (_b = mutator.extractWithPath(sanity.pathToString(fieldPath), doc)[0]) != null ? _b : {};
-      let arrayPaths = [];
-      if (arrayValue != null && arrayValue.length)
-        for (const item of arrayValue) {
-          const itemPath = [...fieldPath, { _key: item._key }];
-          let itemSchema = fieldSchema.of.find((t) => t.name === item._type);
-          if (item._type || (itemSchema = fieldSchema.of[0]), item._key && itemSchema) {
-            const innerFields = extractPaths(
-              doc,
-              itemSchema,
-              itemPath
-            ), arrayMember = {
-              path: itemPath,
-              name: item._key,
-              schemaType: itemSchema,
-              value: item
-            };
-            arrayPaths = [...arrayPaths, arrayMember, ...innerFields];
+var common, hasRequiredCommon;
+function requireCommon() {
+  if (hasRequiredCommon)
+    return common;
+  hasRequiredCommon = 1;
+  function setup(env) {
+    createDebug.debug = createDebug, createDebug.default = createDebug, createDebug.coerce = coerce, createDebug.disable = disable, createDebug.enable = enable, createDebug.enabled = enabled, createDebug.humanize = requireMs(), createDebug.destroy = destroy, Object.keys(env).forEach((key) => {
+      createDebug[key] = env[key];
+    }), createDebug.names = [], createDebug.skips = [], createDebug.formatters = {};
+    function selectColor(namespace) {
+      let hash = 0;
+      for (let i = 0; i < namespace.length; i++)
+        hash = (hash << 5) - hash + namespace.charCodeAt(i), hash |= 0;
+      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+    }
+    createDebug.selectColor = selectColor;
+    function createDebug(namespace) {
+      let prevTime, enableOverride = null, namespacesCache, enabledCache;
+      function debug2(...args) {
+        if (!debug2.enabled)
+          return;
+        const self2 = debug2, curr = Number(/* @__PURE__ */ new Date()), ms2 = curr - (prevTime || curr);
+        self2.diff = ms2, self2.prev = prevTime, self2.curr = curr, prevTime = curr, args[0] = createDebug.coerce(args[0]), typeof args[0] != "string" && args.unshift("%O");
+        let index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match2, format) => {
+          if (match2 === "%%")
+            return "%";
+          index++;
+          const formatter = createDebug.formatters[format];
+          if (typeof formatter == "function") {
+            const val = args[index];
+            match2 = formatter.call(self2, val), args.splice(index, 1), index--;
           }
+          return match2;
+        }), createDebug.formatArgs.call(self2, args), (self2.log || createDebug.log).apply(self2, args);
+      }
+      return debug2.namespace = namespace, debug2.useColors = createDebug.useColors(), debug2.color = createDebug.selectColor(namespace), debug2.extend = extend, debug2.destroy = createDebug.destroy, Object.defineProperty(debug2, "enabled", {
+        enumerable: !0,
+        configurable: !1,
+        get: () => enableOverride !== null ? enableOverride : (namespacesCache !== createDebug.namespaces && (namespacesCache = createDebug.namespaces, enabledCache = createDebug.enabled(namespace)), enabledCache),
+        set: (v) => {
+          enableOverride = v;
         }
-      return [...acc, thisFieldWithPath, ...arrayPaths];
+      }), typeof createDebug.init == "function" && createDebug.init(debug2), debug2;
     }
-    return [...acc, thisFieldWithPath];
-  }, []);
+    function extend(namespace, delimiter) {
+      const newDebug = createDebug(this.namespace + (typeof delimiter > "u" ? ":" : delimiter) + namespace);
+      return newDebug.log = this.log, newDebug;
+    }
+    function enable(namespaces) {
+      createDebug.save(namespaces), createDebug.namespaces = namespaces, createDebug.names = [], createDebug.skips = [];
+      const split = (typeof namespaces == "string" ? namespaces : "").trim().replace(" ", ",").split(",").filter(Boolean);
+      for (const ns of split)
+        ns[0] === "-" ? createDebug.skips.push(ns.slice(1)) : createDebug.names.push(ns);
+    }
+    function matchesTemplate(search, template) {
+      let searchIndex = 0, templateIndex = 0, starIndex = -1, matchIndex = 0;
+      for (; searchIndex < search.length; )
+        if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*"))
+          template[templateIndex] === "*" ? (starIndex = templateIndex, matchIndex = searchIndex, templateIndex++) : (searchIndex++, templateIndex++);
+        else if (starIndex !== -1)
+          templateIndex = starIndex + 1, matchIndex++, searchIndex = matchIndex;
+        else
+          return !1;
+      for (; templateIndex < template.length && template[templateIndex] === "*"; )
+        templateIndex++;
+      return templateIndex === template.length;
+    }
+    function disable() {
+      const namespaces = [
+        ...createDebug.names,
+        ...createDebug.skips.map((namespace) => "-" + namespace)
+      ].join(",");
+      return createDebug.enable(""), namespaces;
+    }
+    function enabled(name) {
+      for (const skip of createDebug.skips)
+        if (matchesTemplate(name, skip))
+          return !1;
+      for (const ns of createDebug.names)
+        if (matchesTemplate(name, ns))
+          return !0;
+      return !1;
+    }
+    function coerce(val) {
+      return val instanceof Error ? val.stack || val.message : val;
+    }
+    function destroy() {
+      console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+    }
+    return createDebug.enable(createDebug.load()), createDebug;
+  }
+  return common = setup, common;
 }
-function LanguageOption(props) {
-  var _a;
-  const {
-    language,
-    schemaType,
-    documentId,
-    current,
-    source,
-    sourceLanguageId,
-    metadata: metadata2,
-    metadataId
-  } = props, [userHasClicked, setUserHasClicked] = react.useState(!1), disabled = props.disabled || userHasClicked || current || !source || !sourceLanguageId || !metadataId, translation = metadata2 != null && metadata2.translations.length ? metadata2.translations.find((t) => t._key === language.id) : void 0, { apiVersion, languageField, weakReferences } = useDocumentInternationalizationContext(), client = sanity.useClient({ apiVersion }), toast = ui.useToast(), open = useOpenInNewPane((_a = translation == null ? void 0 : translation.value) == null ? void 0 : _a._ref, schemaType.name), handleOpen = react.useCallback(() => open(), [open]);
-  react.useEffect(() => {
-    setUserHasClicked(!1);
-  }, [!!translation]);
-  const handleCreate = react.useCallback(async () => {
-    if (!source)
-      throw new Error("Cannot create translation without source document");
-    if (!sourceLanguageId)
-      throw new Error("Cannot create translation without source language ID");
-    if (!metadataId)
-      throw new Error("Cannot create translation without a metadata ID");
-    setUserHasClicked(!0);
-    const transaction = client.transaction(), newTranslationDocumentId = uuid.uuid();
-    let newTranslationDocument = {
-      ...source,
-      _id: `drafts.${newTranslationDocumentId}`,
-      // 2. Update language of the translation
-      [languageField]: language.id
+var hasRequiredBrowser$1;
+function requireBrowser$1() {
+  return hasRequiredBrowser$1 || (hasRequiredBrowser$1 = 1, function(module2, exports2) {
+    exports2.formatArgs = formatArgs, exports2.save = save, exports2.load = load, exports2.useColors = useColors, exports2.storage = localstorage(), exports2.destroy = /* @__PURE__ */ (() => {
+      let warned = !1;
+      return () => {
+        warned || (warned = !0, console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."));
+      };
+    })(), exports2.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window < "u" && window.process && (window.process.type === "renderer" || window.process.__nwjs))
+        return !0;
+      if (typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/))
+        return !1;
+      let m;
+      return typeof document < "u" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window < "u" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator < "u" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      if (args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff), !this.useColors)
+        return;
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0, lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match2) => {
+        match2 !== "%%" && (index++, match2 === "%c" && (lastC = index));
+      }), args.splice(lastC, 0, c);
+    }
+    exports2.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        namespaces ? exports2.storage.setItem("debug", namespaces) : exports2.storage.removeItem("debug");
+      } catch (error) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports2.storage.getItem("debug");
+      } catch (error) {
+      }
+      return !r && typeof process < "u" && "env" in process && (r = process.env.DEBUG), r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module2.exports = requireCommon()(exports2);
+    const { formatters } = module2.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
     };
-    newTranslationDocument = removeExcludedPaths(
-      newTranslationDocument,
-      schemaType
-    ), transaction.create(newTranslationDocument);
-    const sourceReference = createReference(
-      sourceLanguageId,
-      documentId,
-      schemaType.name,
-      !weakReferences
-    ), newTranslationReference = createReference(
-      language.id,
-      newTranslationDocumentId,
-      schemaType.name,
-      !weakReferences
-    ), newMetadataDocument = {
-      _id: metadataId,
-      _type: METADATA_SCHEMA_NAME,
-      schemaTypes: [schemaType.name],
-      translations: [sourceReference]
+  }(browser$1, browser$1.exports)), browser$1.exports;
+}
+var node = { exports: {} }, browser, hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser)
+    return browser;
+  hasRequiredBrowser = 1;
+  function getChromeVersion() {
+    const matches = new RegExp("(Chrome|Chromium)\\/(?<chromeVersion>\\d+)\\.").exec(navigator.userAgent);
+    if (matches)
+      return Number.parseInt(matches.groups.chromeVersion, 10);
+  }
+  const colorSupport = getChromeVersion() >= 69 ? {
+    level: 1,
+    hasBasic: !0,
+    has256: !1,
+    has16m: !1
+  } : !1;
+  return browser = {
+    stdout: colorSupport,
+    stderr: colorSupport
+  }, browser;
+}
+var hasRequiredNode;
+function requireNode() {
+  return hasRequiredNode || (hasRequiredNode = 1, function(module2, exports2) {
+    const tty = require$$0__default.default, util = require$$1__default.default;
+    exports2.init = init, exports2.log = log, exports2.formatArgs = formatArgs, exports2.save = save, exports2.load = load, exports2.useColors = useColors, exports2.destroy = util.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    ), exports2.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      const supportsColor = requireBrowser();
+      supportsColor && (supportsColor.stderr || supportsColor).level >= 2 && (exports2.colors = [
+        20,
+        21,
+        26,
+        27,
+        32,
+        33,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        56,
+        57,
+        62,
+        63,
+        68,
+        69,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        92,
+        93,
+        98,
+        99,
+        112,
+        113,
+        128,
+        129,
+        134,
+        135,
+        148,
+        149,
+        160,
+        161,
+        162,
+        163,
+        164,
+        165,
+        166,
+        167,
+        168,
+        169,
+        170,
+        171,
+        172,
+        173,
+        178,
+        179,
+        184,
+        185,
+        196,
+        197,
+        198,
+        199,
+        200,
+        201,
+        202,
+        203,
+        204,
+        205,
+        206,
+        207,
+        208,
+        209,
+        214,
+        215,
+        220,
+        221
+      ]);
+    } catch (error) {
+    }
+    exports2.inspectOpts = Object.keys(process.env).filter((key) => /^debug_/i.test(key)).reduce((obj, key) => {
+      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => k.toUpperCase());
+      let val = process.env[key];
+      return /^(yes|on|true|enabled)$/i.test(val) ? val = !0 : /^(no|off|false|disabled)$/i.test(val) ? val = !1 : val === "null" ? val = null : val = Number(val), obj[prop] = val, obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports2.inspectOpts ? !!exports2.inspectOpts.colors : tty.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      const { namespace: name, useColors: useColors2 } = this;
+      if (useColors2) {
+        const c = this.color, colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c), prefix = `  ${colorCode};1m${name} \x1B[0m`;
+        args[0] = prefix + args[0].split(`
+`).join(`
+` + prefix), args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
+      } else
+        args[0] = getDate() + name + " " + args[0];
+    }
+    function getDate() {
+      return exports2.inspectOpts.hideDate ? "" : (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util.formatWithOptions(exports2.inspectOpts, ...args) + `
+`);
+    }
+    function save(namespaces) {
+      namespaces ? process.env.DEBUG = namespaces : delete process.env.DEBUG;
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug2) {
+      debug2.inspectOpts = {};
+      const keys = Object.keys(exports2.inspectOpts);
+      for (let i = 0; i < keys.length; i++)
+        debug2.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];
+    }
+    module2.exports = requireCommon()(exports2);
+    const { formatters } = module2.exports;
+    formatters.o = function(v) {
+      return this.inspectOpts.colors = this.useColors, util.inspect(v, this.inspectOpts).split(`
+`).map((str) => str.trim()).join(" ");
+    }, formatters.O = function(v) {
+      return this.inspectOpts.colors = this.useColors, util.inspect(v, this.inspectOpts);
     };
-    transaction.createIfNotExists(newMetadataDocument);
-    const metadataPatch = client.patch(metadataId).setIfMissing({ translations: [sourceReference] }).insert("after", "translations[-1]", [newTranslationReference]);
-    transaction.patch(metadataPatch), transaction.commit().then(() => {
-      const metadataExisted = !!(metadata2 != null && metadata2._createdAt);
-      return toast.push({
-        status: "success",
-        title: `Created "${language.title}" translation`,
-        description: metadataExisted ? "Updated Translations Metadata" : "Created Translations Metadata"
-      });
-    }).catch((err) => (console.error(err), setUserHasClicked(!1), toast.push({
-      status: "error",
-      title: "Error creating translation",
-      description: err.message
-    })));
-  }, [
-    client,
-    documentId,
-    language.id,
-    language.title,
-    languageField,
-    metadata2 == null ? void 0 : metadata2._createdAt,
-    metadataId,
-    schemaType,
-    source,
-    sourceLanguageId,
-    toast,
-    weakReferences
-  ]);
-  let message;
-  return current ? message = "Current document" : translation ? message = `Open ${language.title} translation` : translation || (message = `Create new ${language.title} translation`), /* @__PURE__ */ jsxRuntime.jsx(
-    ui.Tooltip,
-    {
-      animate: !0,
-      content: /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding: 2, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { muted: !0, size: 1, children: message }) }),
-      fallbackPlacements: ["right", "left"],
+  }(node, node.exports)), node.exports;
+}
+typeof process > "u" || process.type === "renderer" || process.browser === !0 || process.__nwjs ? src.exports = requireBrowser$1() : src.exports = requireNode();
+var srcExports = src.exports, debugIt = /* @__PURE__ */ getDefaultExportFromCjs(srcExports), Symbol$1 = _Symbol, isArguments = isArguments_1, isArray = isArray_1, spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : void 0;
+function isFlattenable$1(value) {
+  return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
+}
+var _isFlattenable = isFlattenable$1, arrayPush = _arrayPush, isFlattenable = _isFlattenable;
+function baseFlatten$1(array, depth, predicate, isStrict, result) {
+  var index = -1, length = array.length;
+  for (predicate || (predicate = isFlattenable), result || (result = []); ++index < length; ) {
+    var value = array[index];
+    depth > 0 && predicate(value) ? depth > 1 ? baseFlatten$1(value, depth - 1, predicate, isStrict, result) : arrayPush(result, value) : isStrict || (result[result.length] = value);
+  }
+  return result;
+}
+var _baseFlatten = baseFlatten$1, baseFlatten = _baseFlatten;
+function flatten(array) {
+  var length = array == null ? 0 : array.length;
+  return length ? baseFlatten(array, 1) : [];
+}
+var flatten_1 = flatten, flatten$1 = /* @__PURE__ */ getDefaultExportFromCjs(flatten_1);
+function isHighSurrogate(char) {
+  const charCode = char.charCodeAt(0);
+  return charCode >= 55296 && charCode <= 56319;
+}
+function isLowSurrogate(char) {
+  const charCode = char.charCodeAt(0);
+  return charCode >= 56320 && charCode <= 57343;
+}
+function cloneDiff(diff2) {
+  const [type, patch] = diff2;
+  return [type, patch];
+}
+function getCommonOverlap(textA, textB) {
+  let text1 = textA, text2 = textB;
+  const text1Length = text1.length, text2Length = text2.length;
+  if (text1Length === 0 || text2Length === 0)
+    return 0;
+  text1Length > text2Length ? text1 = text1.substring(text1Length - text2Length) : text1Length < text2Length && (text2 = text2.substring(0, text1Length));
+  const textLength = Math.min(text1Length, text2Length);
+  if (text1 === text2)
+    return textLength;
+  let best = 0, length = 1;
+  for (let found = 0; found !== -1; ) {
+    const pattern = text1.substring(textLength - length);
+    if (found = text2.indexOf(pattern), found === -1)
+      return best;
+    length += found, (found === 0 || text1.substring(textLength - length) === text2.substring(0, length)) && (best = length, length++);
+  }
+  return best;
+}
+function getCommonPrefix(text1, text2) {
+  if (!text1 || !text2 || text1[0] !== text2[0])
+    return 0;
+  let pointerMin = 0, pointerMax = Math.min(text1.length, text2.length), pointerMid = pointerMax, pointerStart = 0;
+  for (; pointerMin < pointerMid; )
+    text1.substring(pointerStart, pointerMid) === text2.substring(pointerStart, pointerMid) ? (pointerMin = pointerMid, pointerStart = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);
+  return pointerMid;
+}
+function getCommonSuffix(text1, text2) {
+  if (!text1 || !text2 || text1[text1.length - 1] !== text2[text2.length - 1])
+    return 0;
+  let pointerMin = 0, pointerMax = Math.min(text1.length, text2.length), pointerMid = pointerMax, pointerEnd = 0;
+  for (; pointerMin < pointerMid; )
+    text1.substring(text1.length - pointerMid, text1.length - pointerEnd) === text2.substring(text2.length - pointerMid, text2.length - pointerEnd) ? (pointerMin = pointerMid, pointerEnd = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);
+  return pointerMid;
+}
+function cleanupSemantic(rawDiffs) {
+  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2)), hasChanges = !1;
+  const equalities = [];
+  let equalitiesLength = 0, lastEquality = null, pointer = 0, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0;
+  for (; pointer < diffs.length; )
+    diffs[pointer][0] === DIFF_EQUAL ? (equalities[equalitiesLength++] = pointer, lengthInsertions1 = lengthInsertions2, lengthDeletions1 = lengthDeletions2, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = diffs[pointer][1]) : (diffs[pointer][0] === DIFF_INSERT ? lengthInsertions2 += diffs[pointer][1].length : lengthDeletions2 += diffs[pointer][1].length, lastEquality && lastEquality.length <= Math.max(lengthInsertions1, lengthDeletions1) && lastEquality.length <= Math.max(lengthInsertions2, lengthDeletions2) && (diffs.splice(equalities[equalitiesLength - 1], 0, [DIFF_DELETE, lastEquality]), diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT, equalitiesLength--, equalitiesLength--, pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = null, hasChanges = !0)), pointer++;
+  for (hasChanges && (diffs = cleanupMerge(diffs)), diffs = cleanupSemanticLossless(diffs), pointer = 1; pointer < diffs.length; ) {
+    if (diffs[pointer - 1][0] === DIFF_DELETE && diffs[pointer][0] === DIFF_INSERT) {
+      const deletion = diffs[pointer - 1][1], insertion = diffs[pointer][1], overlapLength1 = getCommonOverlap(deletion, insertion), overlapLength2 = getCommonOverlap(insertion, deletion);
+      overlapLength1 >= overlapLength2 ? (overlapLength1 >= deletion.length / 2 || overlapLength1 >= insertion.length / 2) && (diffs.splice(pointer, 0, [DIFF_EQUAL, insertion.substring(0, overlapLength1)]), diffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlapLength1), diffs[pointer + 1][1] = insertion.substring(overlapLength1), pointer++) : (overlapLength2 >= deletion.length / 2 || overlapLength2 >= insertion.length / 2) && (diffs.splice(pointer, 0, [DIFF_EQUAL, deletion.substring(0, overlapLength2)]), diffs[pointer - 1][0] = DIFF_INSERT, diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlapLength2), diffs[pointer + 1][0] = DIFF_DELETE, diffs[pointer + 1][1] = deletion.substring(overlapLength2), pointer++), pointer++;
+    }
+    pointer++;
+  }
+  return diffs;
+}
+const nonAlphaNumericRegex = /[^a-zA-Z0-9]/, whitespaceRegex = /\s/, linebreakRegex = /[\r\n]/, blanklineEndRegex = /\n\r?\n$/, blanklineStartRegex = /^\r?\n\r?\n/;
+function cleanupSemanticLossless(rawDiffs) {
+  const diffs = rawDiffs.map((diff2) => cloneDiff(diff2));
+  function diffCleanupSemanticScore(one, two) {
+    if (!one || !two)
+      return 6;
+    const char1 = one.charAt(one.length - 1), char2 = two.charAt(0), nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex), nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex), whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex), whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex), lineBreak1 = whitespace1 && char1.match(linebreakRegex), lineBreak2 = whitespace2 && char2.match(linebreakRegex), blankLine1 = lineBreak1 && one.match(blanklineEndRegex), blankLine2 = lineBreak2 && two.match(blanklineStartRegex);
+    return blankLine1 || blankLine2 ? 5 : lineBreak1 || lineBreak2 ? 4 : nonAlphaNumeric1 && !whitespace1 && whitespace2 ? 3 : whitespace1 || whitespace2 ? 2 : nonAlphaNumeric1 || nonAlphaNumeric2 ? 1 : 0;
+  }
+  let pointer = 1;
+  for (; pointer < diffs.length - 1; ) {
+    if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
+      let equality1 = diffs[pointer - 1][1], edit = diffs[pointer][1], equality2 = diffs[pointer + 1][1];
+      const commonOffset = getCommonSuffix(equality1, edit);
+      if (commonOffset) {
+        const commonString = edit.substring(edit.length - commonOffset);
+        equality1 = equality1.substring(0, equality1.length - commonOffset), edit = commonString + edit.substring(0, edit.length - commonOffset), equality2 = commonString + equality2;
+      }
+      let bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2, bestScore = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);
+      for (; edit.charAt(0) === equality2.charAt(0); ) {
+        equality1 += edit.charAt(0), edit = edit.substring(1) + equality2.charAt(0), equality2 = equality2.substring(1);
+        const score = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(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++;
+  }
+  return diffs;
+}
+function cleanupMerge(rawDiffs) {
+  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2));
+  diffs.push([DIFF_EQUAL, ""]);
+  let pointer = 0, countDelete = 0, countInsert = 0, textDelete = "", textInsert = "", commonlength;
+  for (; pointer < diffs.length; )
+    switch (diffs[pointer][0]) {
+      case DIFF_INSERT:
+        countInsert++, textInsert += diffs[pointer][1], pointer++;
+        break;
+      case DIFF_DELETE:
+        countDelete++, textDelete += diffs[pointer][1], pointer++;
+        break;
+      case DIFF_EQUAL:
+        countDelete + countInsert > 1 ? (countDelete !== 0 && countInsert !== 0 && (commonlength = getCommonPrefix(textInsert, textDelete), commonlength !== 0 && (pointer - countDelete - countInsert > 0 && diffs[pointer - countDelete - countInsert - 1][0] === DIFF_EQUAL ? diffs[pointer - countDelete - countInsert - 1][1] += textInsert.substring(0, commonlength) : (diffs.splice(0, 0, [DIFF_EQUAL, textInsert.substring(0, commonlength)]), pointer++), textInsert = textInsert.substring(commonlength), textDelete = textDelete.substring(commonlength)), commonlength = getCommonSuffix(textInsert, textDelete), commonlength !== 0 && (diffs[pointer][1] = textInsert.substring(textInsert.length - commonlength) + diffs[pointer][1], textInsert = textInsert.substring(0, textInsert.length - commonlength), textDelete = textDelete.substring(0, textDelete.length - commonlength))), pointer -= countDelete + countInsert, diffs.splice(pointer, countDelete + countInsert), textDelete.length && (diffs.splice(pointer, 0, [DIFF_DELETE, textDelete]), pointer++), textInsert.length && (diffs.splice(pointer, 0, [DIFF_INSERT, textInsert]), pointer++), pointer++) : pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL ? (diffs[pointer - 1][1] += diffs[pointer][1], diffs.splice(pointer, 1)) : pointer++, countInsert = 0, countDelete = 0, textDelete = "", textInsert = "";
+        break;
+      default:
+        throw new Error("Unknown diff operation");
+    }
+  diffs[diffs.length - 1][1] === "" && diffs.pop();
+  let hasChanges = !1;
+  for (pointer = 1; pointer < diffs.length - 1; )
+    diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL && (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), hasChanges = !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), hasChanges = !0)), pointer++;
+  return hasChanges && (diffs = cleanupMerge(diffs)), diffs;
+}
+function bisect(text1, text2, deadline) {
+  const text1Length = text1.length, text2Length = text2.length, maxD = Math.ceil((text1Length + text2Length) / 2), vOffset = maxD, vLength = 2 * maxD, v1 = new Array(vLength), v2 = new Array(vLength);
+  for (let x = 0; x < vLength; x++)
+    v1[x] = -1, v2[x] = -1;
+  v1[vOffset + 1] = 0, v2[vOffset + 1] = 0;
+  const delta = text1Length - text2Length, front = delta % 2 !== 0;
+  let k1start = 0, k1end = 0, k2start = 0, k2end = 0;
+  for (let d = 0; d < maxD && !(Date.now() > deadline); d++) {
+    for (let k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
+      const k1Offset = vOffset + k1;
+      let x1;
+      k1 === -d || k1 !== d && v1[k1Offset - 1] < v1[k1Offset + 1] ? x1 = v1[k1Offset + 1] : x1 = v1[k1Offset - 1] + 1;
+      let y1 = x1 - k1;
+      for (; x1 < text1Length && y1 < text2Length && text1.charAt(x1) === text2.charAt(y1); )
+        x1++, y1++;
+      if (v1[k1Offset] = x1, x1 > text1Length)
+        k1end += 2;
+      else if (y1 > text2Length)
+        k1start += 2;
+      else if (front) {
+        const k2Offset = vOffset + delta - k1;
+        if (k2Offset >= 0 && k2Offset < vLength && v2[k2Offset] !== -1) {
+          const x2 = text1Length - v2[k2Offset];
+          if (x1 >= x2)
+            return bisectSplit(text1, text2, x1, y1, deadline);
+        }
+      }
+    }
+    for (let k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
+      const k2Offset = vOffset + k2;
+      let x2;
+      k2 === -d || k2 !== d && v2[k2Offset - 1] < v2[k2Offset + 1] ? x2 = v2[k2Offset + 1] : x2 = v2[k2Offset - 1] + 1;
+      let y2 = x2 - k2;
+      for (; x2 < text1Length && y2 < text2Length && text1.charAt(text1Length - x2 - 1) === text2.charAt(text2Length - y2 - 1); )
+        x2++, y2++;
+      if (v2[k2Offset] = x2, x2 > text1Length)
+        k2end += 2;
+      else if (y2 > text2Length)
+        k2start += 2;
+      else if (!front) {
+        const k1Offset = vOffset + delta - k2;
+        if (k1Offset >= 0 && k1Offset < vLength && v1[k1Offset] !== -1) {
+          const x1 = v1[k1Offset], y1 = vOffset + x1 - k1Offset;
+          if (x2 = text1Length - x2, x1 >= x2)
+            return bisectSplit(text1, text2, x1, y1, deadline);
+        }
+      }
+    }
+  }
+  return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
+}
+function bisectSplit(text1, text2, x, y, deadline) {
+  const text1a = text1.substring(0, x), text2a = text2.substring(0, y), text1b = text1.substring(x), text2b = text2.substring(y), diffs = doDiff(text1a, text2a, {
+    checkLines: !1,
+    deadline
+  }), diffsb = doDiff(text1b, text2b, {
+    checkLines: !1,
+    deadline
+  });
+  return diffs.concat(diffsb);
+}
+function findHalfMatch(text1, text2) {
+  if ((arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1) <= 0)
+    return null;
+  const longText = text1.length > text2.length ? text1 : text2, shortText = text1.length > text2.length ? text2 : text1;
+  if (longText.length < 4 || shortText.length * 2 < longText.length)
+    return null;
+  const halfMatch1 = halfMatchI(longText, shortText, Math.ceil(longText.length / 4)), halfMatch2 = halfMatchI(longText, shortText, Math.ceil(longText.length / 2));
+  let halfMatch;
+  if (halfMatch1 && halfMatch2)
+    halfMatch = halfMatch1[4].length > halfMatch2[4].length ? halfMatch1 : halfMatch2;
+  else {
+    if (!halfMatch1 && !halfMatch2)
+      return null;
+    halfMatch2 ? halfMatch1 || (halfMatch = halfMatch2) : halfMatch = halfMatch1;
+  }
+  if (!halfMatch)
+    throw new Error("Unable to find a half match.");
+  let text1A, text1B, text2A, text2B;
+  text1.length > text2.length ? (text1A = halfMatch[0], text1B = halfMatch[1], text2A = halfMatch[2], text2B = halfMatch[3]) : (text2A = halfMatch[0], text2B = halfMatch[1], text1A = halfMatch[2], text1B = halfMatch[3]);
+  const midCommon = halfMatch[4];
+  return [text1A, text1B, text2A, text2B, midCommon];
+}
+function halfMatchI(longText, shortText, i) {
+  const seed = longText.slice(i, i + Math.floor(longText.length / 4));
+  let j = -1, bestCommon = "", bestLongTextA, bestLongTextB, bestShortTextA, bestShortTextB;
+  for (; (j = shortText.indexOf(seed, j + 1)) !== -1; ) {
+    const prefixLength = getCommonPrefix(longText.slice(i), shortText.slice(j)), suffixLength = getCommonSuffix(longText.slice(0, i), shortText.slice(0, j));
+    bestCommon.length < suffixLength + prefixLength && (bestCommon = shortText.slice(j - suffixLength, j) + shortText.slice(j, j + prefixLength), bestLongTextA = longText.slice(0, i - suffixLength), bestLongTextB = longText.slice(i + prefixLength), bestShortTextA = shortText.slice(0, j - suffixLength), bestShortTextB = shortText.slice(j + prefixLength));
+  }
+  return bestCommon.length * 2 >= longText.length ? [bestLongTextA || "", bestLongTextB || "", bestShortTextA || "", bestShortTextB || "", bestCommon || ""] : null;
+}
+function charsToLines(diffs, lineArray) {
+  for (let x = 0; x < diffs.length; x++) {
+    const chars = diffs[x][1], text = [];
+    for (let y = 0; y < chars.length; y++)
+      text[y] = lineArray[chars.charCodeAt(y)];
+    diffs[x][1] = text.join("");
+  }
+}
+function linesToChars(textA, textB) {
+  const lineArray = [], lineHash = {};
+  lineArray[0] = "";
+  function diffLinesToMunge(text) {
+    let chars = "", lineStart = 0, lineEnd = -1, lineArrayLength = lineArray.length;
+    for (; lineEnd < text.length - 1; ) {
+      lineEnd = text.indexOf(`
+`, lineStart), lineEnd === -1 && (lineEnd = text.length - 1);
+      let line = text.slice(lineStart, lineEnd + 1);
+      (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) : lineHash[line] !== void 0) ? chars += String.fromCharCode(lineHash[line]) : (lineArrayLength === maxLines && (line = text.slice(lineStart), lineEnd = text.length), chars += String.fromCharCode(lineArrayLength), lineHash[line] = lineArrayLength, lineArray[lineArrayLength++] = line), lineStart = lineEnd + 1;
+    }
+    return chars;
+  }
+  let maxLines = 4e4;
+  const chars1 = diffLinesToMunge(textA);
+  maxLines = 65535;
+  const chars2 = diffLinesToMunge(textB);
+  return {
+    chars1,
+    chars2,
+    lineArray
+  };
+}
+function doLineModeDiff(textA, textB, opts) {
+  let text1 = textA, text2 = textB;
+  const a = linesToChars(text1, text2);
+  text1 = a.chars1, text2 = a.chars2;
+  const linearray = a.lineArray;
+  let diffs = doDiff(text1, text2, {
+    checkLines: !1,
+    deadline: opts.deadline
+  });
+  charsToLines(diffs, linearray), diffs = cleanupSemantic(diffs), diffs.push([DIFF_EQUAL, ""]);
+  let pointer = 0, countDelete = 0, countInsert = 0, textDelete = "", textInsert = "";
+  for (; pointer < diffs.length; ) {
+    switch (diffs[pointer][0]) {
+      case DIFF_INSERT:
+        countInsert++, textInsert += diffs[pointer][1];
+        break;
+      case DIFF_DELETE:
+        countDelete++, textDelete += diffs[pointer][1];
+        break;
+      case DIFF_EQUAL:
+        if (countDelete >= 1 && countInsert >= 1) {
+          diffs.splice(pointer - countDelete - countInsert, countDelete + countInsert), pointer = pointer - countDelete - countInsert;
+          const aa = doDiff(textDelete, textInsert, {
+            checkLines: !1,
+            deadline: opts.deadline
+          });
+          for (let j = aa.length - 1; j >= 0; j--)
+            diffs.splice(pointer, 0, aa[j]);
+          pointer += aa.length;
+        }
+        countInsert = 0, countDelete = 0, textDelete = "", textInsert = "";
+        break;
+      default:
+        throw new Error("Unknown diff operation.");
+    }
+    pointer++;
+  }
+  return diffs.pop(), diffs;
+}
+function computeDiff(text1, text2, opts) {
+  let diffs;
+  if (!text1)
+    return [[DIFF_INSERT, text2]];
+  if (!text2)
+    return [[DIFF_DELETE, text1]];
+  const longtext = text1.length > text2.length ? text1 : text2, shorttext = text1.length > text2.length ? text2 : text1, i = longtext.indexOf(shorttext);
+  if (i !== -1)
+    return diffs = [[DIFF_INSERT, longtext.substring(0, i)], [DIFF_EQUAL, shorttext], [DIFF_INSERT, longtext.substring(i + shorttext.length)]], text1.length > text2.length && (diffs[0][0] = DIFF_DELETE, diffs[2][0] = DIFF_DELETE), diffs;
+  if (shorttext.length === 1)
+    return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
+  const halfMatch = findHalfMatch(text1, text2);
+  if (halfMatch) {
+    const text1A = halfMatch[0], text1B = halfMatch[1], text2A = halfMatch[2], text2B = halfMatch[3], midCommon = halfMatch[4], diffsA = doDiff(text1A, text2A, opts), diffsB = doDiff(text1B, text2B, opts);
+    return diffsA.concat([[DIFF_EQUAL, midCommon]], diffsB);
+  }
+  return opts.checkLines && text1.length > 100 && text2.length > 100 ? doLineModeDiff(text1, text2, opts) : bisect(text1, text2, opts.deadline);
+}
+const DIFF_DELETE = -1, DIFF_INSERT = 1, DIFF_EQUAL = 0;
+function diff(textA, textB, opts) {
+  if (textA === null || textB === null)
+    throw new Error("Null input. (diff)");
+  const diffs = doDiff(textA, textB, createInternalOpts(opts || {}));
+  return adjustDiffForSurrogatePairs(diffs), diffs;
+}
+function doDiff(textA, textB, options) {
+  let text1 = textA, text2 = textB;
+  if (text1 === text2)
+    return text1 ? [[DIFF_EQUAL, text1]] : [];
+  let commonlength = getCommonPrefix(text1, text2);
+  const commonprefix = text1.substring(0, commonlength);
+  text1 = text1.substring(commonlength), text2 = text2.substring(commonlength), commonlength = getCommonSuffix(text1, text2);
+  const commonsuffix = text1.substring(text1.length - commonlength);
+  text1 = text1.substring(0, text1.length - commonlength), text2 = text2.substring(0, text2.length - commonlength);
+  let diffs = computeDiff(text1, text2, options);
+  return commonprefix && diffs.unshift([DIFF_EQUAL, commonprefix]), commonsuffix && diffs.push([DIFF_EQUAL, commonsuffix]), diffs = cleanupMerge(diffs), diffs;
+}
+function createDeadLine(timeout) {
+  let t = 1;
+  return typeof timeout < "u" && (t = timeout <= 0 ? Number.MAX_VALUE : timeout), Date.now() + t * 1e3;
+}
+function createInternalOpts(opts) {
+  return __spreadValues({
+    checkLines: !0,
+    deadline: createDeadLine(opts.timeout || 1)
+  }, opts);
+}
+function combineChar(data, char, dir) {
+  return dir === 1 ? data + char : char + data;
+}
+function splitChar(data, dir) {
+  return dir === 1 ? [data.substring(0, data.length - 1), data[data.length - 1]] : [data.substring(1), data[0]];
+}
+function hasSharedChar(diffs, i, j, dir) {
+  return dir === 1 ? diffs[i][1][diffs[i][1].length - 1] === diffs[j][1][diffs[j][1].length - 1] : diffs[i][1][0] === diffs[j][1][0];
+}
+function deisolateChar(diffs, i, dir) {
+  const inv = dir === 1 ? -1 : 1;
+  let insertIdx = null, deleteIdx = null, j = i + dir;
+  for (; j >= 0 && j < diffs.length && (insertIdx === null || deleteIdx === null); j += dir) {
+    const [op, text2] = diffs[j];
+    if (text2.length !== 0) {
+      if (op === DIFF_INSERT) {
+        insertIdx === null && (insertIdx = j);
+        continue;
+      } else if (op === DIFF_DELETE) {
+        deleteIdx === null && (deleteIdx = j);
+        continue;
+      } else if (op === DIFF_EQUAL) {
+        if (insertIdx === null && deleteIdx === null) {
+          const [rest, char2] = splitChar(diffs[i][1], dir);
+          diffs[i][1] = rest, diffs[j][1] = combineChar(diffs[j][1], char2, inv);
+          return;
+        }
+        break;
+      }
+    }
+  }
+  if (insertIdx !== null && deleteIdx !== null && hasSharedChar(diffs, insertIdx, deleteIdx, dir)) {
+    const [insertText, insertChar] = splitChar(diffs[insertIdx][1], inv), [deleteText] = splitChar(diffs[deleteIdx][1], inv);
+    diffs[insertIdx][1] = insertText, diffs[deleteIdx][1] = deleteText, diffs[i][1] = combineChar(diffs[i][1], insertChar, dir);
+    return;
+  }
+  const [text, char] = splitChar(diffs[i][1], dir);
+  diffs[i][1] = text, insertIdx === null ? (diffs.splice(j, 0, [DIFF_INSERT, char]), deleteIdx !== null && deleteIdx >= j && deleteIdx++) : diffs[insertIdx][1] = combineChar(diffs[insertIdx][1], char, inv), deleteIdx === null ? diffs.splice(j, 0, [DIFF_DELETE, char]) : diffs[deleteIdx][1] = combineChar(diffs[deleteIdx][1], char, inv);
+}
+function adjustDiffForSurrogatePairs(diffs) {
+  for (let i = 0; i < diffs.length; i++) {
+    const [diffType, diffText] = diffs[i];
+    if (diffText.length === 0)
+      continue;
+    const firstChar = diffText[0], lastChar = diffText[diffText.length - 1];
+    isHighSurrogate(lastChar) && diffType === DIFF_EQUAL && deisolateChar(diffs, i, 1), isLowSurrogate(firstChar) && diffType === DIFF_EQUAL && deisolateChar(diffs, i, -1);
+  }
+  for (let i = 0; i < diffs.length; i++)
+    diffs[i][1].length === 0 && diffs.splice(i, 1);
+}
+const DEFAULT_OPTIONS = {
+  /**
+   * At what point is no match declared (0.0 = perfection, 1.0 = very loose).
+   */
+  threshold: 0.5,
+  /**
+   * How far to search for a match (0 = exact location, 1000+ = broad match).
+   * A match this many characters away from the expected location will add
+   * 1.0 to the score (0.0 is a perfect match).
+   */
+  distance: 1e3
+};
+function applyDefaults(options) {
+  return __spreadValues(__spreadValues({}, DEFAULT_OPTIONS), options);
+}
+const MAX_BITS$1 = 32;
+function bitap(text, pattern, loc) {
+  let opts = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
+  if (pattern.length > MAX_BITS$1)
+    throw new Error("Pattern too long for this browser.");
+  const options = applyDefaults(opts), s = getAlphabetFromPattern(pattern);
+  function getBitapScore(e, x) {
+    const accuracy = e / pattern.length, proximity = Math.abs(loc - x);
+    return options.distance ? accuracy + proximity / options.distance : proximity ? 1 : accuracy;
+  }
+  let scoreThreshold = options.threshold, bestLoc = text.indexOf(pattern, loc);
+  bestLoc !== -1 && (scoreThreshold = Math.min(getBitapScore(0, bestLoc), scoreThreshold), bestLoc = text.lastIndexOf(pattern, loc + pattern.length), bestLoc !== -1 && (scoreThreshold = Math.min(getBitapScore(0, bestLoc), scoreThreshold)));
+  const matchmask = 1 << pattern.length - 1;
+  bestLoc = -1;
+  let binMin, binMid, binMax = pattern.length + text.length, lastRd = [];
+  for (let d = 0; d < pattern.length; d++) {
+    for (binMin = 0, binMid = binMax; binMin < binMid; )
+      getBitapScore(d, loc + binMid) <= scoreThreshold ? binMin = binMid : binMax = binMid, binMid = Math.floor((binMax - binMin) / 2 + binMin);
+    binMax = binMid;
+    let start = Math.max(1, loc - binMid + 1);
+    const finish = Math.min(loc + binMid, text.length) + pattern.length, rd = new Array(finish + 2);
+    rd[finish + 1] = (1 << d) - 1;
+    for (let j = finish; j >= start; j--) {
+      const charMatch = s[text.charAt(j - 1)];
+      if (d === 0 ? rd[j] = (rd[j + 1] << 1 | 1) & charMatch : rd[j] = (rd[j + 1] << 1 | 1) & charMatch | ((lastRd[j + 1] | lastRd[j]) << 1 | 1) | lastRd[j + 1], rd[j] & matchmask) {
+        const score = getBitapScore(d, j - 1);
+        if (score <= scoreThreshold)
+          if (scoreThreshold = score, bestLoc = j - 1, bestLoc > loc)
+            start = Math.max(1, 2 * loc - bestLoc);
+          else
+            break;
+      }
+    }
+    if (getBitapScore(d + 1, loc) > scoreThreshold)
+      break;
+    lastRd = rd;
+  }
+  return bestLoc;
+}
+function getAlphabetFromPattern(pattern) {
+  const s = {};
+  for (let i = 0; i < pattern.length; i++)
+    s[pattern.charAt(i)] = 0;
+  for (let i = 0; i < pattern.length; i++)
+    s[pattern.charAt(i)] |= 1 << pattern.length - i - 1;
+  return s;
+}
+function match(text, pattern, searchLocation) {
+  if (text === null || pattern === null || searchLocation === null)
+    throw new Error("Null input. (match())");
+  const loc = Math.max(0, Math.min(searchLocation, text.length));
+  if (text === pattern)
+    return 0;
+  if (text.length) {
+    if (text.substring(loc, loc + pattern.length) === pattern)
+      return loc;
+  } else
+    return -1;
+  return bitap(text, pattern, loc);
+}
+function createPatchObject(start1, start2) {
+  return {
+    diffs: [],
+    start1,
+    start2,
+    utf8Start1: start1,
+    utf8Start2: start2,
+    length1: 0,
+    length2: 0,
+    utf8Length1: 0,
+    utf8Length2: 0
+  };
+}
+function diffText1(diffs) {
+  const text = [];
+  for (let x = 0; x < diffs.length; x++)
+    diffs[x][0] !== DIFF_INSERT && (text[x] = diffs[x][1]);
+  return text.join("");
+}
+function diffText2(diffs) {
+  const text = [];
+  for (let x = 0; x < diffs.length; x++)
+    diffs[x][0] !== DIFF_DELETE && (text[x] = diffs[x][1]);
+  return text.join("");
+}
+function countUtf8Bytes(str) {
+  let bytes = 0;
+  for (let i = 0; i < str.length; i++) {
+    const codePoint = str.codePointAt(i);
+    if (typeof codePoint > "u")
+      throw new Error("Failed to get codepoint");
+    bytes += utf8len(codePoint);
+  }
+  return bytes;
+}
+function adjustIndiciesToUcs2(patches, base) {
+  let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, byteOffset = 0, idx = 0;
+  function advanceTo(target) {
+    for (; byteOffset < target; ) {
+      const codePoint = base.codePointAt(idx);
+      if (typeof codePoint > "u")
+        return idx;
+      byteOffset += utf8len(codePoint), codePoint > 65535 ? idx += 2 : idx += 1;
+    }
+    if (!options.allowExceedingIndices && byteOffset !== target)
+      throw new Error("Failed to determine byte offset");
+    return idx;
+  }
+  const adjusted = [];
+  for (const patch of patches)
+    adjusted.push({
+      diffs: patch.diffs.map((diff2) => cloneDiff(diff2)),
+      start1: advanceTo(patch.start1),
+      start2: advanceTo(patch.start2),
+      utf8Start1: patch.utf8Start1,
+      utf8Start2: patch.utf8Start2,
+      length1: patch.length1,
+      length2: patch.length2,
+      utf8Length1: patch.utf8Length1,
+      utf8Length2: patch.utf8Length2
+    });
+  return adjusted;
+}
+function utf8len(codePoint) {
+  return codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
+}
+const MAX_BITS = 32, DEFAULT_MARGIN = 4;
+function levenshtein(diffs) {
+  let leven = 0, insertions = 0, deletions = 0;
+  for (let x = 0; x < diffs.length; x++) {
+    const op = diffs[x][0], data = diffs[x][1];
+    switch (op) {
+      case DIFF_INSERT:
+        insertions += data.length;
+        break;
+      case DIFF_DELETE:
+        deletions += data.length;
+        break;
+      case DIFF_EQUAL:
+        leven += Math.max(insertions, deletions), insertions = 0, deletions = 0;
+        break;
+      default:
+        throw new Error("Unknown diff operation.");
+    }
+  }
+  return leven += Math.max(insertions, deletions), leven;
+}
+function xIndex(diffs, loc) {
+  let chars1 = 0, chars2 = 0, lastChars1 = 0, lastChars2 = 0, x;
+  for (x = 0; x < diffs.length && (diffs[x][0] !== DIFF_INSERT && (chars1 += diffs[x][1].length), diffs[x][0] !== DIFF_DELETE && (chars2 += diffs[x][1].length), !(chars1 > loc)); x++)
+    lastChars1 = chars1, lastChars2 = chars2;
+  return diffs.length !== x && diffs[x][0] === DIFF_DELETE ? lastChars2 : lastChars2 + (loc - lastChars1);
+}
+function addPadding(patches) {
+  const paddingLength = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_MARGIN;
+  let nullPadding = "";
+  for (let x = 1; x <= paddingLength; x++)
+    nullPadding += String.fromCharCode(x);
+  for (const p of patches)
+    p.start1 += paddingLength, p.start2 += paddingLength, p.utf8Start1 += paddingLength, p.utf8Start2 += paddingLength;
+  let patch = patches[0], diffs = patch.diffs;
+  if (diffs.length === 0 || diffs[0][0] !== DIFF_EQUAL)
+    diffs.unshift([DIFF_EQUAL, nullPadding]), patch.start1 -= paddingLength, patch.start2 -= paddingLength, patch.utf8Start1 -= paddingLength, patch.utf8Start2 -= paddingLength, patch.length1 += paddingLength, patch.length2 += paddingLength, patch.utf8Length1 += paddingLength, patch.utf8Length2 += paddingLength;
+  else if (paddingLength > diffs[0][1].length) {
+    const firstDiffLength = diffs[0][1].length, extraLength = paddingLength - firstDiffLength;
+    diffs[0][1] = nullPadding.substring(firstDiffLength) + diffs[0][1], patch.start1 -= extraLength, patch.start2 -= extraLength, patch.utf8Start1 -= extraLength, patch.utf8Start2 -= extraLength, patch.length1 += extraLength, patch.length2 += extraLength, patch.utf8Length1 += extraLength, patch.utf8Length2 += extraLength;
+  }
+  if (patch = patches[patches.length - 1], diffs = patch.diffs, diffs.length === 0 || diffs[diffs.length - 1][0] !== DIFF_EQUAL)
+    diffs.push([DIFF_EQUAL, nullPadding]), patch.length1 += paddingLength, patch.length2 += paddingLength, patch.utf8Length1 += paddingLength, patch.utf8Length2 += paddingLength;
+  else if (paddingLength > diffs[diffs.length - 1][1].length) {
+    const extraLength = paddingLength - diffs[diffs.length - 1][1].length;
+    diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength), patch.length1 += extraLength, patch.length2 += extraLength, patch.utf8Length1 += extraLength, patch.utf8Length2 += extraLength;
+  }
+  return nullPadding;
+}
+function splitMax(patches) {
+  let margin = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_MARGIN;
+  const patchSize = MAX_BITS;
+  for (let x = 0; x < patches.length; x++) {
+    if (patches[x].length1 <= patchSize)
+      continue;
+    const bigpatch = patches[x];
+    patches.splice(x--, 1);
+    let start1 = bigpatch.start1, start2 = bigpatch.start2, preContext = "";
+    for (; bigpatch.diffs.length !== 0; ) {
+      const patch = createPatchObject(start1 - preContext.length, start2 - preContext.length);
+      let empty = !0;
+      if (preContext !== "") {
+        const precontextByteCount = countUtf8Bytes(preContext);
+        patch.length1 = preContext.length, patch.utf8Length1 = precontextByteCount, patch.length2 = preContext.length, patch.utf8Length2 = precontextByteCount, patch.diffs.push([DIFF_EQUAL, preContext]);
+      }
+      for (; bigpatch.diffs.length !== 0 && patch.length1 < patchSize - margin; ) {
+        const diffType = bigpatch.diffs[0][0];
+        let diffText = bigpatch.diffs[0][1], diffTextByteCount = countUtf8Bytes(diffText);
+        if (diffType === DIFF_INSERT) {
+          patch.length2 += diffText.length, patch.utf8Length2 += diffTextByteCount, start2 += diffText.length;
+          const diff2 = bigpatch.diffs.shift();
+          diff2 && patch.diffs.push(diff2), empty = !1;
+        } else
+          diffType === DIFF_DELETE && patch.diffs.length === 1 && patch.diffs[0][0] === DIFF_EQUAL && diffText.length > 2 * patchSize ? (patch.length1 += diffText.length, patch.utf8Length1 += diffTextByteCount, start1 += diffText.length, empty = !1, patch.diffs.push([diffType, diffText]), bigpatch.diffs.shift()) : (diffText = diffText.substring(0, patchSize - patch.length1 - margin), diffTextByteCount = countUtf8Bytes(diffText), patch.length1 += diffText.length, patch.utf8Length1 += diffTextByteCount, start1 += diffText.length, diffType === DIFF_EQUAL ? (patch.length2 += diffText.length, patch.utf8Length2 += diffTextByteCount, start2 += diffText.length) : empty = !1, patch.diffs.push([diffType, diffText]), diffText === bigpatch.diffs[0][1] ? bigpatch.diffs.shift() : bigpatch.diffs[0][1] = bigpatch.diffs[0][1].substring(diffText.length));
+      }
+      preContext = diffText2(patch.diffs), preContext = preContext.substring(preContext.length - margin);
+      const postContext = diffText1(bigpatch.diffs).substring(0, margin), postContextByteCount = countUtf8Bytes(postContext);
+      postContext !== "" && (patch.length1 += postContext.length, patch.length2 += postContext.length, patch.utf8Length1 += postContextByteCount, patch.utf8Length2 += postContextByteCount, patch.diffs.length !== 0 && patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL ? patch.diffs[patch.diffs.length - 1][1] += postContext : patch.diffs.push([DIFF_EQUAL, postContext])), empty || patches.splice(++x, 0, patch);
+    }
+  }
+}
+function apply(patches, originalText) {
+  let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  if (typeof patches == "string")
+    throw new Error("Patches must be an array - pass the patch to `parsePatch()` first");
+  let text = originalText;
+  if (patches.length === 0)
+    return [text, []];
+  const parsed = adjustIndiciesToUcs2(patches, text, {
+    allowExceedingIndices: opts.allowExceedingIndices
+  }), margin = opts.margin || DEFAULT_MARGIN, deleteThreshold = opts.deleteThreshold || 0.4, nullPadding = addPadding(parsed, margin);
+  text = nullPadding + text + nullPadding, splitMax(parsed, margin);
+  let delta = 0;
+  const results = [];
+  for (let x = 0; x < parsed.length; x++) {
+    const expectedLoc = parsed[x].start2 + delta, text1 = diffText1(parsed[x].diffs);
+    let startLoc, endLoc = -1;
+    if (text1.length > MAX_BITS ? (startLoc = match(text, text1.substring(0, MAX_BITS), expectedLoc), startLoc !== -1 && (endLoc = match(text, text1.substring(text1.length - MAX_BITS), expectedLoc + text1.length - MAX_BITS), (endLoc === -1 || startLoc >= endLoc) && (startLoc = -1))) : startLoc = match(text, text1, expectedLoc), startLoc === -1)
+      results[x] = !1, delta -= parsed[x].length2 - parsed[x].length1;
+    else {
+      results[x] = !0, delta = startLoc - expectedLoc;
+      let text2;
+      if (endLoc === -1 ? text2 = text.substring(startLoc, startLoc + text1.length) : text2 = text.substring(startLoc, endLoc + MAX_BITS), text1 === text2)
+        text = text.substring(0, startLoc) + diffText2(parsed[x].diffs) + text.substring(startLoc + text1.length);
+      else {
+        let diffs = diff(text1, text2, {
+          checkLines: !1
+        });
+        if (text1.length > MAX_BITS && levenshtein(diffs) / text1.length > deleteThreshold)
+          results[x] = !1;
+        else {
+          diffs = cleanupSemanticLossless(diffs);
+          let index1 = 0, index2 = 0;
+          for (let y = 0; y < parsed[x].diffs.length; y++) {
+            const mod = parsed[x].diffs[y];
+            mod[0] !== DIFF_EQUAL && (index2 = xIndex(diffs, index1)), mod[0] === DIFF_INSERT ? text = text.substring(0, startLoc + index2) + mod[1] + text.substring(startLoc + index2) : mod[0] === DIFF_DELETE && (text = text.substring(0, startLoc + index2) + text.substring(startLoc + xIndex(diffs, index1 + mod[1].length))), mod[0] !== DIFF_DELETE && (index1 += mod[1].length);
+          }
+        }
+      }
+    }
+  }
+  return text = text.substring(nullPadding.length, text.length - nullPadding.length), [text, results];
+}
+const patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/;
+function parse(textline) {
+  if (!textline)
+    return [];
+  const patches = [], lines = textline.split(`
+`);
+  let textPointer = 0;
+  for (; textPointer < lines.length; ) {
+    const m = lines[textPointer].match(patchHeader);
+    if (!m)
+      throw new Error("Invalid patch string: ".concat(lines[textPointer]));
+    const patch = createPatchObject(toInt(m[1]), toInt(m[3]));
+    for (patches.push(patch), m[2] === "" ? (patch.start1--, patch.utf8Start1--, patch.length1 = 1, patch.utf8Length1 = 1) : m[2] === "0" ? (patch.length1 = 0, patch.utf8Length1 = 0) : (patch.start1--, patch.utf8Start1--, patch.utf8Length1 = toInt(m[2]), patch.length1 = patch.utf8Length1), m[4] === "" ? (patch.start2--, patch.utf8Start2--, patch.length2 = 1, patch.utf8Length2 = 1) : m[4] === "0" ? (patch.length2 = 0, patch.utf8Length2 = 0) : (patch.start2--, patch.utf8Start2--, patch.utf8Length2 = toInt(m[4]), patch.length2 = patch.utf8Length2), textPointer++; textPointer < lines.length; ) {
+      const currentLine = lines[textPointer], sign = currentLine.charAt(0);
+      if (sign === "@")
+        break;
+      if (sign === "") {
+        textPointer++;
+        continue;
+      }
+      let line;
+      try {
+        line = decodeURI(currentLine.slice(1));
+      } catch (ex) {
+        throw new Error("Illegal escape in parse: ".concat(currentLine));
+      }
+      const utf8Diff = countUtf8Bytes(line) - line.length;
+      if (sign === "-")
+        patch.diffs.push([DIFF_DELETE, line]), patch.length1 -= utf8Diff;
+      else if (sign === "+")
+        patch.diffs.push([DIFF_INSERT, line]), patch.length2 -= utf8Diff;
+      else if (sign === " ")
+        patch.diffs.push([DIFF_EQUAL, line]), patch.length1 -= utf8Diff, patch.length2 -= utf8Diff;
+      else
+        throw new Error('Invalid patch mode "'.concat(sign, '" in: ').concat(line));
+      textPointer++;
+    }
+  }
+  return patches;
+}
+function toInt(num) {
+  return parseInt(num, 10);
+}
+var baseGetTag = _baseGetTag, isObjectLike = isObjectLike_1, symbolTag = "[object Symbol]";
+function isSymbol$1(value) {
+  return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+}
+var isSymbol_1 = isSymbol$1, isSymbol = isSymbol_1;
+function baseExtremum$2(array, iteratee, comparator) {
+  for (var index = -1, length = array.length; ++index < length; ) {
+    var value = array[index], current = iteratee(value);
+    if (current != null && (computed === void 0 ? current === current && !isSymbol(current) : comparator(current, computed)))
+      var computed = current, result = value;
+  }
+  return result;
+}
+var _baseExtremum = baseExtremum$2;
+function baseGt$1(value, other) {
+  return value > other;
+}
+var _baseGt = baseGt$1;
+function identity$2(value) {
+  return value;
+}
+var identity_1 = identity$2, baseExtremum$1 = _baseExtremum, baseGt = _baseGt, identity$1 = identity_1;
+function max(array) {
+  return array && array.length ? baseExtremum$1(array, identity$1, baseGt) : void 0;
+}
+var max_1 = max, max$1 = /* @__PURE__ */ getDefaultExportFromCjs(max_1);
+function baseLt$1(value, other) {
+  return value < other;
+}
+var _baseLt = baseLt$1, baseExtremum = _baseExtremum, baseLt = _baseLt, identity = identity_1;
+function min(array) {
+  return array && array.length ? baseExtremum(array, identity, baseLt) : void 0;
+}
+var min_1 = min, min$1 = /* @__PURE__ */ getDefaultExportFromCjs(min_1);
+function compact(array) {
+  for (var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = []; ++index < length; ) {
+    var value = array[index];
+    value && (result[resIndex++] = value);
+  }
+  return result;
+}
+var compact_1 = compact, compact$1 = /* @__PURE__ */ getDefaultExportFromCjs(compact_1);
+const debug = debugIt("mutator-document");
+var __defProp$h = Object.defineProperty, __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$h = (obj, key, value) => __defNormalProp$h(obj, typeof key != "symbol" ? key + "" : key, value);
+class ImmutableAccessor {
+  constructor(value, path) {
+    __publicField$h(this, "_value"), __publicField$h(this, "path"), this._value = value, this.path = path || [];
+  }
+  containerType() {
+    return Array.isArray(this._value) ? "array" : this._value !== null && typeof this._value == "object" ? "object" : "primitive";
+  }
+  // Common reader, supported by all containers
+  get() {
+    return this._value;
+  }
+  // Array reader
+  length() {
+    if (!Array.isArray(this._value))
+      throw new Error("Won't return length of non-indexable _value");
+    return this._value.length;
+  }
+  getIndex(i) {
+    return Array.isArray(this._value) ? i >= this.length() ? null : new ImmutableAccessor(this._value[i], this.path.concat(i)) : !1;
+  }
+  // Object reader
+  hasAttribute(key) {
+    return isRecord$1(this._value) ? this._value.hasOwnProperty(key) : !1;
+  }
+  attributeKeys() {
+    return isRecord$1(this._value) ? Object.keys(this._value) : [];
+  }
+  getAttribute(key) {
+    if (!isRecord$1(this._value))
+      throw new Error("getAttribute only applies to plain objects");
+    return this.hasAttribute(key) ? new ImmutableAccessor(this._value[key], this.path.concat(key)) : null;
+  }
+  // Common writer, supported by all containers
+  set(value) {
+    return value === this._value ? this : new ImmutableAccessor(value, this.path);
+  }
+  // array writer interface
+  setIndex(i, value) {
+    if (!Array.isArray(this._value))
+      throw new Error("setIndex only applies to arrays");
+    if (Object.is(value, this._value[i]))
+      return this;
+    const nextValue = this._value.slice();
+    return nextValue[i] = value, new ImmutableAccessor(nextValue, this.path);
+  }
+  setIndexAccessor(i, accessor) {
+    return this.setIndex(i, accessor.get());
+  }
+  unsetIndices(indices) {
+    if (!Array.isArray(this._value))
+      throw new Error("unsetIndices only applies to arrays");
+    const length = this._value.length, nextValue = [];
+    for (let i = 0; i < length; i++)
+      indices.indexOf(i) === -1 && nextValue.push(this._value[i]);
+    return new ImmutableAccessor(nextValue, this.path);
+  }
+  insertItemsAt(pos, items) {
+    if (!Array.isArray(this._value))
+      throw new Error("insertItemsAt only applies to arrays");
+    let nextValue;
+    return this._value.length === 0 && pos === 0 ? nextValue = items : nextValue = this._value.slice(0, pos).concat(items).concat(this._value.slice(pos)), new ImmutableAccessor(nextValue, this.path);
+  }
+  // Object writer interface
+  setAttribute(key, value) {
+    if (!isRecord$1(this._value))
+      throw new Error("Unable to set attribute of non-object container");
+    if (Object.is(value, this._value[key]))
+      return this;
+    const nextValue = Object.assign({}, this._value, { [key]: value });
+    return new ImmutableAccessor(nextValue, this.path);
+  }
+  setAttributeAccessor(key, accessor) {
+    return this.setAttribute(key, accessor.get());
+  }
+  unsetAttribute(key) {
+    if (!isRecord$1(this._value))
+      throw new Error("Unable to unset attribute of non-object container");
+    const nextValue = Object.assign({}, this._value);
+    return delete nextValue[key], new ImmutableAccessor(nextValue, this.path);
+  }
+}
+function isRecord$1(value) {
+  return value !== null && typeof value == "object";
+}
+function isRecord(value) {
+  return value !== null && typeof value == "object";
+}
+function descend$1(tail) {
+  const [head, newTail] = splitIfPath(tail);
+  if (!head)
+    throw new Error("Head cannot be null");
+  return spreadIfUnionHead(head, newTail);
+}
+function splitIfPath(tail) {
+  if (tail.type !== "path")
+    return [tail, null];
+  const nodes = tail.nodes;
+  return nodes.length === 0 ? [null, null] : nodes.length === 1 ? [nodes[0], null] : [nodes[0], { type: "path", nodes: nodes.slice(1) }];
+}
+function concatPaths(path1, path2) {
+  if (!path1 && !path2)
+    return null;
+  const nodes1 = path1 ? path1.nodes : [], nodes2 = path2 ? path2.nodes : [];
+  return {
+    type: "path",
+    nodes: nodes1.concat(nodes2)
+  };
+}
+function spreadIfUnionHead(head, tail) {
+  return head.type !== "union" ? [[head, tail]] : head.nodes.map((node2) => {
+    if (node2.type === "path") {
+      const [subHead, subTail] = splitIfPath(node2);
+      return [subHead, concatPaths(subTail, tail)];
+    }
+    return [node2, tail];
+  });
+}
+var __defProp$g = Object.defineProperty, __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$g = (obj, key, value) => __defNormalProp$g(obj, typeof key != "symbol" ? key + "" : key, value);
+const digitChar = /[0-9]/, attributeCharMatcher = /^[a-zA-Z0-9_]$/, attributeFirstCharMatcher = /^[a-zA-Z_]$/, symbols = {
+  // NOTE: These are compared against in order of definition,
+  // thus '==' must come before '=', '>=' before '>', etc.
+  operator: ["..", ".", ",", ":", "?"],
+  comparator: [">=", "<=", "<", ">", "==", "!="],
+  keyword: ["$", "@"],
+  boolean: ["true", "false"],
+  paren: ["[", "]"]
+}, symbolClasses = Object.keys(symbols);
+class Tokenizer {
+  constructor(path) {
+    __publicField$g(this, "source"), __publicField$g(this, "i"), __publicField$g(this, "length"), __publicField$g(this, "tokenizers"), this.source = path, this.length = path.length, this.i = 0, this.tokenizers = [
+      this.tokenizeSymbol,
+      this.tokenizeIdentifier,
+      this.tokenizeNumber,
+      this.tokenizeQuoted
+    ].map((fn) => fn.bind(this));
+  }
+  tokenize() {
+    const result = [];
+    for (; !this.EOF(); ) {
+      this.chompWhitespace();
+      let token = null;
+      if (!this.tokenizers.some((tokenizer) => (token = tokenizer(), !!token)) || !token)
+        throw new Error(`Invalid tokens in jsonpath '${this.source}' @ ${this.i}`);
+      result.push(token);
+    }
+    return result;
+  }
+  takeWhile(fn) {
+    const start = this.i;
+    let result = "";
+    for (; !this.EOF(); ) {
+      const nextChar = fn(this.source[this.i]);
+      if (nextChar === null)
+        break;
+      result += nextChar, this.i++;
+    }
+    return this.i === start ? null : result;
+  }
+  EOF() {
+    return this.i >= this.length;
+  }
+  peek() {
+    return this.EOF() ? null : this.source[this.i];
+  }
+  consume(str) {
+    if (this.i + str.length > this.length)
+      throw new Error(`Expected ${str} at end of jsonpath`);
+    if (str === this.source.slice(this.i, this.i + str.length))
+      this.i += str.length;
+    else
+      throw new Error(`Expected "${str}", but source contained "${this.source.slice()}`);
+  }
+  // Tries to match the upcoming bit of string with the provided string. If it matches, returns
+  // the string, then advances the read pointer to the next bit. If not, returns null and nothing
+  // happens.
+  tryConsume(str) {
+    if (this.i + str.length > this.length)
+      return null;
+    if (str === this.source.slice(this.i, this.i + str.length)) {
+      if (str[0].match(attributeCharMatcher) && this.length > this.i + str.length) {
+        const nextChar = this.source[this.i + str.length];
+        if (nextChar && nextChar.match(attributeCharMatcher))
+          return null;
+      }
+      return this.i += str.length, str;
+    }
+    return null;
+  }
+  chompWhitespace() {
+    this.takeWhile((char) => char === " " ? "" : null);
+  }
+  tokenizeQuoted() {
+    const quote = this.peek();
+    if (quote === "'" || quote === '"') {
+      this.consume(quote);
+      let escape = !1;
+      const inner = this.takeWhile((char) => escape ? (escape = !1, char) : char === "\\" ? (escape = !0, "") : char != quote ? char : null);
+      return this.consume(quote), {
+        type: "quoted",
+        value: inner,
+        quote: quote === '"' ? "double" : "single"
+      };
+    }
+    return null;
+  }
+  tokenizeIdentifier() {
+    let first = !0;
+    const identifier = this.takeWhile((char) => first ? (first = !1, char.match(attributeFirstCharMatcher) ? char : null) : char.match(attributeCharMatcher) ? char : null);
+    return identifier !== null ? {
+      type: "identifier",
+      name: identifier
+    } : null;
+  }
+  tokenizeNumber() {
+    const start = this.i;
+    let dotSeen = !1, digitSeen = !1, negative = !1;
+    this.peek() === "-" && (negative = !0, this.consume("-"));
+    const number = this.takeWhile((char) => char === "." && !dotSeen && digitSeen ? (dotSeen = !0, char) : (digitSeen = !0, char.match(digitChar) ? char : null));
+    return number !== null ? {
+      type: "number",
+      value: negative ? -number : +number,
+      raw: negative ? `-${number}` : number
+    } : (this.i = start, null);
+  }
+  tokenizeSymbol() {
+    for (const symbolClass of symbolClasses) {
+      const symbol = symbols[symbolClass].find((pattern) => this.tryConsume(pattern));
+      if (symbol)
+        return {
+          type: symbolClass,
+          symbol
+        };
+    }
+    return null;
+  }
+}
+function tokenize(jsonpath) {
+  return new Tokenizer(jsonpath).tokenize();
+}
+var __defProp$f = Object.defineProperty, __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$f = (obj, key, value) => __defNormalProp$f(obj, typeof key != "symbol" ? key + "" : key, value);
+class Parser {
+  constructor(path) {
+    __publicField$f(this, "tokens"), __publicField$f(this, "length"), __publicField$f(this, "i"), this.tokens = tokenize(path), this.length = this.tokens.length, this.i = 0;
+  }
+  parse() {
+    return this.parsePath();
+  }
+  EOF() {
+    return this.i >= this.length;
+  }
+  // Look at upcoming token
+  peek() {
+    return this.EOF() ? null : this.tokens[this.i];
+  }
+  consume() {
+    const result = this.peek();
+    return this.i += 1, result;
+  }
+  // Return next token if it matches the pattern
+  probe(pattern) {
+    const token = this.peek();
+    if (!token)
+      return null;
+    const record = token;
+    return Object.keys(pattern).every((key) => key in token && pattern[key] === record[key]) ? token : null;
+  }
+  // Return and consume next token if it matches the pattern
+  match(pattern) {
+    return this.probe(pattern) ? this.consume() : null;
+  }
+  parseAttribute() {
+    const token = this.match({ type: "identifier" });
+    if (token && token.type === "identifier")
+      return {
+        type: "attribute",
+        name: token.name
+      };
+    const quoted = this.match({ type: "quoted", quote: "single" });
+    return quoted && quoted.type === "quoted" ? {
+      type: "attribute",
+      name: quoted.value || ""
+    } : null;
+  }
+  parseAlias() {
+    return this.match({ type: "keyword", symbol: "@" }) || this.match({ type: "keyword", symbol: "$" }) ? {
+      type: "alias",
+      target: "self"
+    } : null;
+  }
+  parseNumber() {
+    const token = this.match({ type: "number" });
+    return token && token.type === "number" ? {
+      type: "number",
+      value: token.value
+    } : null;
+  }
+  parseNumberValue() {
+    const expr = this.parseNumber();
+    return expr ? expr.value : null;
+  }
+  parseSliceSelector() {
+    const start = this.i, rangeStart = this.parseNumberValue();
+    if (!this.match({ type: "operator", symbol: ":" }))
+      return rangeStart === null ? (this.i = start, null) : { type: "index", value: rangeStart };
+    const result = {
+      type: "range",
+      start: rangeStart,
+      end: this.parseNumberValue()
+    };
+    return this.match({ type: "operator", symbol: ":" }) && (result.step = this.parseNumberValue()), result.start === null && result.end === null ? (this.i = start, null) : result;
+  }
+  parseValueReference() {
+    return this.parseAttribute() || this.parseSliceSelector();
+  }
+  parseLiteralValue() {
+    const literalString = this.match({ type: "quoted", quote: "double" });
+    if (literalString && literalString.type === "quoted")
+      return {
+        type: "string",
+        value: literalString.value || ""
+      };
+    const literalBoolean = this.match({ type: "boolean" });
+    return literalBoolean && literalBoolean.type === "boolean" ? {
+      type: "boolean",
+      value: literalBoolean.symbol === "true"
+    } : this.parseNumber();
+  }
+  // TODO: Reorder constraints so that literal value is always on rhs, and variable is always
+  // on lhs.
+  parseFilterExpression() {
+    const start = this.i, expr = this.parseAttribute() || this.parseAlias();
+    if (!expr)
+      return null;
+    if (this.match({ type: "operator", symbol: "?" }))
+      return {
+        type: "constraint",
+        operator: "?",
+        lhs: expr
+      };
+    const binOp = this.match({ type: "comparator" });
+    if (!binOp || binOp.type !== "comparator")
+      return this.i = start, null;
+    const lhs = expr, rhs = this.parseLiteralValue();
+    if (!rhs)
+      throw new Error(`Operator ${binOp.symbol} needs a literal value at the right hand side`);
+    return {
+      type: "constraint",
+      operator: binOp.symbol,
+      lhs,
+      rhs
+    };
+  }
+  parseExpression() {
+    return this.parseFilterExpression() || this.parseValueReference();
+  }
+  parseUnion() {
+    if (!this.match({ type: "paren", symbol: "[" }))
+      return null;
+    const terms = [];
+    let expr = this.parseFilterExpression() || this.parsePath() || this.parseValueReference();
+    for (; expr && (terms.push(expr), !this.match({ type: "paren", symbol: "]" })); ) {
+      if (!this.match({ type: "operator", symbol: "," }))
+        throw new Error("Expected ]");
+      if (expr = this.parseFilterExpression() || this.parsePath() || this.parseValueReference(), !expr)
+        throw new Error("Expected expression following ','");
+    }
+    return {
+      type: "union",
+      nodes: terms
+    };
+  }
+  parseRecursive() {
+    if (!this.match({ type: "operator", symbol: ".." }))
+      return null;
+    const subpath = this.parsePath();
+    if (!subpath)
+      throw new Error("Expected path following '..' operator");
+    return {
+      type: "recursive",
+      term: subpath
+    };
+  }
+  parsePath() {
+    const nodes = [], expr = this.parseAttribute() || this.parseUnion() || this.parseRecursive();
+    if (!expr)
+      return null;
+    for (nodes.push(expr); !this.EOF(); )
+      if (this.match({ type: "operator", symbol: "." })) {
+        const attr = this.parseAttribute();
+        if (!attr)
+          throw new Error("Expected attribute name following '.");
+        nodes.push(attr);
+        continue;
+      } else if (this.probe({ type: "paren", symbol: "[" })) {
+        const union = this.parseUnion();
+        if (!union)
+          throw new Error("Expected union following '['");
+        nodes.push(union);
+      } else {
+        const recursive = this.parseRecursive();
+        recursive && nodes.push(recursive);
+        break;
+      }
+    return nodes.length === 1 ? nodes[0] : {
+      type: "path",
+      nodes
+    };
+  }
+}
+function parseJsonPath(path) {
+  const parsed = new Parser(path).parse();
+  if (!parsed)
+    throw new Error(`Failed to parse JSON path "${path}"`);
+  return parsed;
+}
+function toPath(expr) {
+  return toPathInner(expr, !1);
+}
+function toPathInner(expr, inUnion) {
+  switch (expr.type) {
+    case "attribute":
+      return expr.name;
+    case "alias":
+      return expr.target === "self" ? "@" : "$";
+    case "number":
+      return `${expr.value}`;
+    case "range": {
+      const result = [];
+      return inUnion || result.push("["), expr.start && result.push(`${expr.start}`), result.push(":"), expr.end && result.push(`${expr.end}`), expr.step && result.push(`:${expr.step}`), inUnion || result.push("]"), result.join("");
+    }
+    case "index":
+      return inUnion ? `${expr.value}` : `[${expr.value}]`;
+    case "constraint": {
+      const rhs = expr.rhs ? ` ${toPathInner(expr.rhs, !1)}` : "", inner = `${toPathInner(expr.lhs, !1)} ${expr.operator}${rhs}`;
+      return inUnion ? inner : `[${inner}]`;
+    }
+    case "string":
+      return JSON.stringify(expr.value);
+    case "path": {
+      const result = [], nodes = expr.nodes.slice();
+      for (; nodes.length > 0; ) {
+        const node2 = nodes.shift();
+        node2 && result.push(toPath(node2));
+        const upcoming = nodes[0];
+        upcoming && toPathInner(upcoming, !1)[0] !== "[" && result.push(".");
+      }
+      return result.join("");
+    }
+    case "union":
+      return `[${expr.nodes.map((e) => toPathInner(e, !0)).join(",")}]`;
+    default:
+      throw new Error(`Unknown node type ${expr.type}`);
+    case "recursive":
+      return `..${toPathInner(expr.term, !1)}`;
+  }
+}
+var __defProp$e = Object.defineProperty, __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$e = (obj, key, value) => __defNormalProp$e(obj, key + "", value);
+class Expression {
+  constructor(expr) {
+    if (__publicField$e(this, "expr"), !expr)
+      throw new Error("Attempted to create Expression from null-value");
+    if ("expr" in expr ? this.expr = expr.expr : this.expr = expr, !("type" in this.expr))
+      throw new Error("Attempt to create Expression for expression with no type");
+  }
+  isPath() {
+    return this.expr.type === "path";
+  }
+  isUnion() {
+    return this.expr.type === "union";
+  }
+  isCollection() {
+    return this.isPath() || this.isUnion();
+  }
+  isConstraint() {
+    return this.expr.type === "constraint";
+  }
+  isRecursive() {
+    return this.expr.type === "recursive";
+  }
+  isExistenceConstraint() {
+    return this.expr.type === "constraint" && this.expr.operator === "?";
+  }
+  isIndex() {
+    return this.expr.type === "index";
+  }
+  isRange() {
+    return this.expr.type === "range";
+  }
+  expandRange(probe) {
+    const probeLength = () => {
+      if (!probe)
+        throw new Error("expandRange() required a probe that was not passed");
+      return probe.length();
+    };
+    let start = "start" in this.expr && this.expr.start || 0;
+    start = interpretNegativeIndex(start, probe);
+    let end = "end" in this.expr && this.expr.end || probeLength();
+    end = interpretNegativeIndex(end, probe);
+    const step = "step" in this.expr && this.expr.step || 1;
+    return { start, end, step };
+  }
+  isAttributeReference() {
+    return this.expr.type === "attribute";
+  }
+  // Is a range or index -> something referencing indexes
+  isIndexReference() {
+    return this.isIndex() || this.isRange();
+  }
+  name() {
+    return "name" in this.expr ? this.expr.name : "";
+  }
+  isSelfReference() {
+    return this.expr.type === "alias" && this.expr.target === "self";
+  }
+  constraintTargetIsSelf() {
+    return this.expr.type === "constraint" && this.expr.lhs.type === "alias" && this.expr.lhs.target === "self";
+  }
+  constraintTargetIsAttribute() {
+    return this.expr.type === "constraint" && this.expr.lhs.type === "attribute";
+  }
+  testConstraint(probe) {
+    const expr = this.expr;
+    if (expr.type === "constraint" && expr.lhs.type === "alias" && expr.lhs.target === "self") {
+      if (probe.containerType() !== "primitive")
+        return !1;
+      if (expr.type === "constraint" && expr.operator === "?")
+        return !0;
+      const lhs2 = probe.get(), rhs2 = expr.rhs && "value" in expr.rhs ? expr.rhs.value : void 0;
+      return testBinaryOperator(lhs2, expr.operator, rhs2);
+    }
+    if (expr.type !== "constraint")
+      return !1;
+    const lhs = expr.lhs;
+    if (!lhs)
+      throw new Error("No LHS of expression");
+    if (lhs.type !== "attribute")
+      throw new Error(`Constraint target ${lhs.type} not supported`);
+    if (probe.containerType() !== "object")
+      return !1;
+    const lhsValue = probe.getAttribute(lhs.name);
+    if (lhsValue == null || lhsValue.containerType() !== "primitive")
+      return !1;
+    if (this.isExistenceConstraint())
+      return !0;
+    const rhs = expr.rhs && "value" in expr.rhs ? expr.rhs.value : void 0;
+    return testBinaryOperator(lhsValue.get(), expr.operator, rhs);
+  }
+  pathNodes() {
+    return this.expr.type === "path" ? this.expr.nodes : [this.expr];
+  }
+  prepend(node2) {
+    return node2 ? new Expression({
+      type: "path",
+      nodes: node2.pathNodes().concat(this.pathNodes())
+    }) : this;
+  }
+  concat(other) {
+    return other ? other.prepend(this) : this;
+  }
+  descend() {
+    return descend$1(this.expr).map((headTail) => {
+      const [head, tail] = headTail;
+      return {
+        head: head ? new Expression(head) : null,
+        tail: tail ? new Expression(tail) : null
+      };
+    });
+  }
+  unwrapRecursive() {
+    if (this.expr.type !== "recursive")
+      throw new Error(`Attempt to unwrap recursive on type ${this.expr.type}`);
+    return new Expression(this.expr.term);
+  }
+  toIndicies(probe) {
+    if (this.expr.type !== "index" && this.expr.type !== "range")
+      throw new Error("Node cannot be converted to indexes");
+    if (this.expr.type === "index")
+      return [interpretNegativeIndex(this.expr.value, probe)];
+    const result = [], range = this.expandRange(probe);
+    let { start, end } = range;
+    range.step < 0 && ([start, end] = [end, start]);
+    for (let i = start; i < end; i++)
+      result.push(i);
+    return result;
+  }
+  toFieldReferences() {
+    if (this.isIndexReference())
+      return this.toIndicies();
+    if (this.expr.type === "attribute")
+      return [this.expr.name];
+    throw new Error(`Can't convert ${this.expr.type} to field references`);
+  }
+  toString() {
+    return toPath(this.expr);
+  }
+  static fromPath(path) {
+    const parsed = parseJsonPath(path);
+    if (!parsed)
+      throw new Error(`Failed to parse path "${path}"`);
+    return new Expression(parsed);
+  }
+  static attributeReference(name) {
+    return new Expression({
+      type: "attribute",
+      name
+    });
+  }
+  static indexReference(i) {
+    return new Expression({
+      type: "index",
+      value: i
+    });
+  }
+}
+function testBinaryOperator(lhsValue, operator, rhsValue) {
+  switch (operator) {
+    case ">":
+      return lhsValue > rhsValue;
+    case ">=":
+      return lhsValue >= rhsValue;
+    case "<":
+      return lhsValue < rhsValue;
+    case "<=":
+      return lhsValue <= rhsValue;
+    case "==":
+      return lhsValue === rhsValue;
+    case "!=":
+      return lhsValue !== rhsValue;
+    default:
+      throw new Error(`Unsupported binary operator ${operator}`);
+  }
+}
+function interpretNegativeIndex(index, probe) {
+  if (index >= 0)
+    return index;
+  if (!probe)
+    throw new Error("interpretNegativeIndex() must have a probe when < 0");
+  return index + probe.length();
+}
+var __defProp$d = Object.defineProperty, __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$d = (obj, key, value) => __defNormalProp$d(obj, typeof key != "symbol" ? key + "" : key, value);
+class Descender {
+  constructor(head, tail) {
+    __publicField$d(this, "head"), __publicField$d(this, "tail"), this.head = head, this.tail = tail;
+  }
+  // Iterate this descender once processing any constraints that are
+  // resolvable on the current value. Returns an array of new descenders
+  // that are guaranteed to be without constraints in the head
+  iterate(probe) {
+    let result = [this];
+    if (this.head && this.head.isConstraint()) {
+      let anyConstraints = !0;
+      for (; anyConstraints; )
+        result = flatten$1(
+          result.map((descender) => descender.iterateConstraints(probe))
+        ), anyConstraints = result.some((descender) => descender.head && descender.head.isConstraint());
+    }
+    return result;
+  }
+  isRecursive() {
+    return !!(this.head && this.head.isRecursive());
+  }
+  hasArrived() {
+    return this.head === null && this.tail === null;
+  }
+  extractRecursives() {
+    if (this.head && this.head.isRecursive()) {
+      const term = this.head.unwrapRecursive();
+      return new Descender(null, term.concat(this.tail)).descend();
+    }
+    return [];
+  }
+  iterateConstraints(probe) {
+    const head = this.head;
+    if (head === null || !head.isConstraint())
+      return [this];
+    const result = [];
+    if (probe.containerType() === "primitive" && head.constraintTargetIsSelf())
+      return head.testConstraint(probe) && result.push(...this.descend()), result;
+    if (probe.containerType() === "array") {
+      const length = probe.length();
+      for (let i = 0; i < length; i++) {
+        const constraint = probe.getIndex(i);
+        constraint && head.testConstraint(constraint) && result.push(new Descender(new Expression({ type: "index", value: i }), this.tail));
+      }
+      return result;
+    }
+    return probe.containerType() === "object" ? head.constraintTargetIsSelf() ? [] : head.testConstraint(probe) ? this.descend() : result : result;
+  }
+  descend() {
+    return this.tail ? this.tail.descend().map((ht) => new Descender(ht.head, ht.tail)) : [new Descender(null, null)];
+  }
+  toString() {
+    const result = ["<"];
+    return this.head && result.push(this.head.toString()), result.push("|"), this.tail && result.push(this.tail.toString()), result.push(">"), result.join("");
+  }
+}
+var __defProp$c = Object.defineProperty, __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$c = (obj, key, value) => __defNormalProp$c(obj, typeof key != "symbol" ? key + "" : key, value);
+class Matcher {
+  constructor(active, parent) {
+    __publicField$c(this, "active"), __publicField$c(this, "recursives"), __publicField$c(this, "payload"), this.active = active || [], parent ? (this.recursives = parent.recursives, this.payload = parent.payload) : this.recursives = [], this.extractRecursives();
+  }
+  setPayload(payload) {
+    return this.payload = payload, this;
+  }
+  // Moves any recursive descenders onto the recursive track, removing them from
+  // the active set
+  extractRecursives() {
+    this.active = this.active.filter((descender) => descender.isRecursive() ? (this.recursives.push(...descender.extractRecursives()), !1) : !0);
+  }
+  // Find recursives that are relevant now and should be considered part of the active set
+  activeRecursives(probe) {
+    return this.recursives.filter((descender) => {
+      const head = descender.head;
+      return head ? head.isConstraint() || probe.containerType() === "array" && head.isIndexReference() ? !0 : probe.containerType() === "object" ? head.isAttributeReference() && probe.hasAttribute(head.name()) : !1 : !1;
+    });
+  }
+  match(probe) {
+    return this.iterate(probe).extractMatches(probe);
+  }
+  iterate(probe) {
+    const newActiveSet = [];
+    return this.active.concat(this.activeRecursives(probe)).forEach((descender) => {
+      newActiveSet.push(...descender.iterate(probe));
+    }), new Matcher(newActiveSet, this);
+  }
+  // Returns true if any of the descenders in the active or recursive set
+  // consider the current state a final destination
+  isDestination() {
+    return this.active.some((descender) => descender.hasArrived());
+  }
+  hasRecursives() {
+    return this.recursives.length > 0;
+  }
+  // Returns any payload delivieries and leads that needs to be followed to complete
+  // the process.
+  extractMatches(probe) {
+    const leads = [], targets = [];
+    if (this.active.forEach((descender) => {
+      if (descender.hasArrived()) {
+        targets.push(
+          new Expression({
+            type: "alias",
+            target: "self"
+          })
+        );
+        return;
+      }
+      const descenderHead = descender.head;
+      if (descenderHead && !(probe.containerType() === "array" && !descenderHead.isIndexReference()) && !(probe.containerType() === "object" && !descenderHead.isAttributeReference()))
+        if (descender.tail) {
+          const matcher = new Matcher(descender.descend(), this);
+          descenderHead.toFieldReferences().forEach(() => {
+            leads.push({
+              target: descenderHead,
+              matcher
+            });
+          });
+        } else
+          targets.push(descenderHead);
+    }), this.hasRecursives()) {
+      const recursivesMatcher = new Matcher([], this);
+      if (probe.containerType() === "array") {
+        const length = probe.length();
+        for (let i = 0; i < length; i++)
+          leads.push({
+            target: Expression.indexReference(i),
+            matcher: recursivesMatcher
+          });
+      } else
+        probe.containerType() === "object" && probe.attributeKeys().forEach((name) => {
+          leads.push({
+            target: Expression.attributeReference(name),
+            matcher: recursivesMatcher
+          });
+        });
+    }
+    return targets.length > 0 ? { leads, delivery: { targets, payload: this.payload } } : { leads };
+  }
+  static fromPath(jsonpath) {
+    const path = parseJsonPath(jsonpath);
+    if (!path)
+      throw new Error(`Failed to parse path from "${jsonpath}"`);
+    const descender = new Descender(null, new Expression(path));
+    return new Matcher(descender.descend());
+  }
+}
+var __defProp$b = Object.defineProperty, __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$b = (obj, key, value) => __defNormalProp$b(obj, typeof key != "symbol" ? key + "" : key, value);
+class PlainProbe {
+  constructor(value, path) {
+    __publicField$b(this, "_value"), __publicField$b(this, "path"), this._value = value, this.path = path || [];
+  }
+  containerType() {
+    return Array.isArray(this._value) ? "array" : this._value !== null && typeof this._value == "object" ? "object" : "primitive";
+  }
+  length() {
+    if (!Array.isArray(this._value))
+      throw new Error("Won't return length of non-indexable _value");
+    return this._value.length;
+  }
+  getIndex(i) {
+    return Array.isArray(this._value) ? i >= this.length() ? null : new PlainProbe(this._value[i], this.path.concat(i)) : !1;
+  }
+  hasAttribute(key) {
+    return isRecord(this._value) ? this._value.hasOwnProperty(key) : !1;
+  }
+  attributeKeys() {
+    return isRecord(this._value) ? Object.keys(this._value) : [];
+  }
+  getAttribute(key) {
+    if (!isRecord(this._value))
+      throw new Error("getAttribute only applies to plain objects");
+    return this.hasAttribute(key) ? new PlainProbe(this._value[key], this.path.concat(key)) : null;
+  }
+  get() {
+    return this._value;
+  }
+}
+function extractAccessors(path, value) {
+  const result = [], matcher = Matcher.fromPath(path).setPayload(function(values) {
+    result.push(...values);
+  }), accessor = new PlainProbe(value);
+  return descend(matcher, accessor), result;
+}
+function descend(matcher, accessor) {
+  const { leads, delivery } = matcher.match(accessor);
+  leads.forEach((lead) => {
+    accessorsFromTarget(lead.target, accessor).forEach((childAccessor) => {
+      descend(lead.matcher, childAccessor);
+    });
+  }), delivery && delivery.targets.forEach((target) => {
+    typeof delivery.payload == "function" && delivery.payload(accessorsFromTarget(target, accessor));
+  });
+}
+function accessorsFromTarget(target, accessor) {
+  const result = [];
+  if (target.isIndexReference())
+    target.toIndicies(accessor).forEach((i) => {
+      result.push(accessor.getIndex(i));
+    });
+  else if (target.isAttributeReference())
+    result.push(accessor.getAttribute(target.name()));
+  else if (target.isSelfReference())
+    result.push(accessor);
+  else
+    throw new Error(`Unable to derive accessor for target ${target.toString()}`);
+  return compact$1(result);
+}
+function extractWithPath(path, value) {
+  return extractAccessors(path, value).map((acc) => ({ path: acc.path, value: acc.get() }));
+}
+var __defProp$a = Object.defineProperty, __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$a = (obj, key, value) => __defNormalProp$a(obj, typeof key != "symbol" ? key + "" : key, value);
+function applyPatch(patch, oldValue) {
+  if (typeof oldValue != "string")
+    return oldValue;
+  const [result] = apply(patch, oldValue, { allowExceedingIndices: !0 });
+  return result;
+}
+class DiffMatchPatch {
+  constructor(id, path, dmpPatchSrc) {
+    __publicField$a(this, "path"), __publicField$a(this, "dmpPatch"), __publicField$a(this, "id"), this.id = id, this.path = path, this.dmpPatch = parse(dmpPatchSrc);
+  }
+  apply(targets, accessor) {
+    let result = accessor;
+    if (result.containerType() === "primitive")
+      return result;
+    for (const target of targets) {
+      if (target.isIndexReference()) {
+        for (const index of target.toIndicies(accessor)) {
+          const item = result.getIndex(index);
+          if (!item)
+            continue;
+          const oldValue = item.get(), nextValue = applyPatch(this.dmpPatch, oldValue);
+          result = result.setIndex(index, nextValue);
+        }
+        continue;
+      }
+      if (target.isAttributeReference() && result.hasAttribute(target.name())) {
+        const attribute = result.getAttribute(target.name());
+        if (!attribute)
+          continue;
+        const oldValue = attribute.get(), nextValue = applyPatch(this.dmpPatch, oldValue);
+        result = result.setAttribute(target.name(), nextValue);
+        continue;
+      }
+      throw new Error(`Unable to apply diffMatchPatch to target ${target.toString()}`);
+    }
+    return result;
+  }
+}
+var __defProp$9 = Object.defineProperty, __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$9 = (obj, key, value) => __defNormalProp$9(obj, typeof key != "symbol" ? key + "" : key, value);
+function performIncrement(previousValue, delta) {
+  return typeof previousValue != "number" || !Number.isFinite(previousValue) ? previousValue : previousValue + delta;
+}
+class IncPatch {
+  constructor(id, path, value) {
+    __publicField$9(this, "path"), __publicField$9(this, "value"), __publicField$9(this, "id"), this.path = path, this.value = value, this.id = id;
+  }
+  apply(targets, accessor) {
+    let result = accessor;
+    if (result.containerType() === "primitive")
+      return result;
+    for (const target of targets) {
+      if (target.isIndexReference()) {
+        for (const index of target.toIndicies(accessor)) {
+          const item = result.getIndex(index);
+          if (!item)
+            continue;
+          const previousValue = item.get();
+          result = result.setIndex(index, performIncrement(previousValue, this.value));
+        }
+        continue;
+      }
+      if (target.isAttributeReference()) {
+        const attribute = result.getAttribute(target.name());
+        if (!attribute)
+          continue;
+        const previousValue = attribute.get();
+        result = result.setAttribute(target.name(), performIncrement(previousValue, this.value));
+        continue;
+      }
+      throw new Error(`Unable to apply to target ${target.toString()}`);
+    }
+    return result;
+  }
+}
+function targetsToIndicies(targets, accessor) {
+  const result = [];
+  return targets.forEach((target) => {
+    target.isIndexReference() && result.push(...target.toIndicies(accessor));
+  }), result.sort();
+}
+var __defProp$8 = Object.defineProperty, __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$8 = (obj, key, value) => __defNormalProp$8(obj, typeof key != "symbol" ? key + "" : key, value);
+class InsertPatch {
+  constructor(id, location, path, items) {
+    __publicField$8(this, "location"), __publicField$8(this, "path"), __publicField$8(this, "items"), __publicField$8(this, "id"), this.id = id, this.location = location, this.path = path, this.items = items;
+  }
+  apply(targets, accessor) {
+    let result = accessor;
+    if (accessor.containerType() !== "array")
+      throw new Error("Attempt to apply insert patch to non-array value");
+    switch (this.location) {
+      case "before": {
+        const pos = minIndex(targets, accessor);
+        result = result.insertItemsAt(pos, this.items);
+        break;
+      }
+      case "after": {
+        const pos = maxIndex(targets, accessor);
+        result = result.insertItemsAt(pos + 1, this.items);
+        break;
+      }
+      case "replace": {
+        const indicies = targetsToIndicies(targets, accessor);
+        result = result.unsetIndices(indicies), result = result.insertItemsAt(indicies[0], this.items);
+        break;
+      }
+      default:
+        throw new Error(`Unsupported location atm: ${this.location}`);
+    }
+    return result;
+  }
+}
+function minIndex(targets, accessor) {
+  let result = min$1(targetsToIndicies(targets, accessor)) || 0;
+  return targets.forEach((target) => {
+    if (target.isRange()) {
+      const { start } = target.expandRange();
+      start < result && (result = start);
+    }
+  }), result;
+}
+function maxIndex(targets, accessor) {
+  let result = max$1(targetsToIndicies(targets, accessor)) || 0;
+  return targets.forEach((target) => {
+    if (target.isRange()) {
+      const { end } = target.expandRange();
+      end > result && (result = end);
+    }
+  }), result;
+}
+var __defProp$7 = Object.defineProperty, __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$7 = (obj, key, value) => __defNormalProp$7(obj, typeof key != "symbol" ? key + "" : key, value);
+class SetIfMissingPatch {
+  constructor(id, path, value) {
+    __publicField$7(this, "id"), __publicField$7(this, "path"), __publicField$7(this, "value"), this.id = id, this.path = path, this.value = value;
+  }
+  apply(targets, accessor) {
+    let result = accessor;
+    return targets.forEach((target) => {
+      if (!target.isIndexReference())
+        if (target.isAttributeReference())
+          result.containerType() === "primitive" ? result = result.set({ [target.name()]: this.value }) : result.hasAttribute(target.name()) || (result = accessor.setAttribute(target.name(), this.value));
+        else
+          throw new Error(`Unable to apply to target ${target.toString()}`);
+    }), result;
+  }
+}
+var __defProp$6 = Object.defineProperty, __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$6 = (obj, key, value) => __defNormalProp$6(obj, typeof key != "symbol" ? key + "" : key, value);
+class SetPatch {
+  constructor(id, path, value) {
+    __publicField$6(this, "id"), __publicField$6(this, "path"), __publicField$6(this, "value"), this.id = id, this.path = path, this.value = value;
+  }
+  apply(targets, accessor) {
+    let result = accessor;
+    return targets.forEach((target) => {
+      if (target.isSelfReference())
+        result = result.set(this.value);
+      else if (target.isIndexReference())
+        target.toIndicies(accessor).forEach((i) => {
+          result = result.setIndex(i, this.value);
+        });
+      else if (target.isAttributeReference())
+        result.containerType() === "primitive" ? result = result.set({ [target.name()]: this.value }) : result = result.setAttribute(target.name(), this.value);
+      else
+        throw new Error(`Unable to apply to target ${target.toString()}`);
+    }), result;
+  }
+}
+var __defProp$5 = Object.defineProperty, __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$5 = (obj, key, value) => __defNormalProp$5(obj, typeof key != "symbol" ? key + "" : key, value);
+class UnsetPatch {
+  constructor(id, path) {
+    __publicField$5(this, "id"), __publicField$5(this, "path"), __publicField$5(this, "value"), this.id = id, this.path = path;
+  }
+  // eslint-disable-next-line class-methods-use-this
+  apply(targets, accessor) {
+    let result = accessor;
+    switch (accessor.containerType()) {
+      case "array":
+        result = result.unsetIndices(targetsToIndicies(targets, accessor));
+        break;
+      case "object":
+        targets.forEach((target) => {
+          result = result.unsetAttribute(target.name());
+        });
+        break;
+      default:
+        throw new Error(
+          "Target value is neither indexable or an object. This error should potentially just be silently ignored?"
+        );
+    }
+    return result;
+  }
+}
+function parsePatch(patch) {
+  const result = [];
+  if (Array.isArray(patch))
+    return patch.reduce((r, p) => r.concat(parsePatch(p)), result);
+  const { set, setIfMissing, unset, diffMatchPatch, inc, dec, insert } = patch;
+  if (setIfMissing && Object.keys(setIfMissing).forEach((path) => {
+    result.push(new SetIfMissingPatch(patch.id, path, setIfMissing[path]));
+  }), set && Object.keys(set).forEach((path) => {
+    result.push(new SetPatch(patch.id, path, set[path]));
+  }), unset && unset.forEach((path) => {
+    result.push(new UnsetPatch(patch.id, path));
+  }), diffMatchPatch && Object.keys(diffMatchPatch).forEach((path) => {
+    result.push(new DiffMatchPatch(patch.id, path, diffMatchPatch[path]));
+  }), inc && Object.keys(inc).forEach((path) => {
+    result.push(new IncPatch(patch.id, path, inc[path]));
+  }), dec && Object.keys(dec).forEach((path) => {
+    result.push(new IncPatch(patch.id, path, -dec[path]));
+  }), insert) {
+    let location, path;
+    const spec = insert;
+    if ("before" in spec)
+      location = "before", path = spec.before;
+    else if ("after" in spec)
+      location = "after", path = spec.after;
+    else if ("replace" in spec)
+      location = "replace", path = spec.replace;
+    else
+      throw new Error("Invalid insert patch");
+    result.push(new InsertPatch(patch.id, location, path, spec.items));
+  }
+  return result;
+}
+var __defProp$4 = Object.defineProperty, __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, key + "", value);
+class Patcher {
+  constructor(patch) {
+    __publicField$4(this, "patches"), this.patches = parsePatch(patch);
+  }
+  apply(value) {
+    const accessor = new ImmutableAccessor(value);
+    return this.applyViaAccessor(accessor).get();
+  }
+  // If you want to use your own accessor implementation, you can use this method
+  // to invoke the patcher. Since all subsequent accessors for children of this accessor
+  // are obtained through the methods in the accessors, you retain full control of the
+  // implementation throguhgout the application. Have a look in ImmutableAccessor
+  // to see an example of how accessors are implemented.
+  applyViaAccessor(accessor) {
+    let result = accessor;
+    const idAccessor = accessor.getAttribute("_id");
+    if (!idAccessor)
+      throw new Error("Cannot apply patch to document with no _id");
+    const id = idAccessor.get();
+    for (const patch of this.patches) {
+      if (patch.id !== id)
+        continue;
+      const matcher = Matcher.fromPath(patch.path).setPayload(patch);
+      result = process$1(matcher, result);
+    }
+    return result;
+  }
+}
+function process$1(matcher, accessor) {
+  const isSetPatch = matcher.payload instanceof SetPatch || matcher.payload instanceof SetIfMissingPatch;
+  let result = accessor;
+  const { leads, delivery } = matcher.match(accessor);
+  return leads.forEach((lead) => {
+    if (lead.target.isIndexReference())
+      lead.target.toIndicies().forEach((i) => {
+        const item = result.getIndex(i);
+        if (!item)
+          throw new Error("Index out of bounds");
+        result = result.setIndexAccessor(i, process$1(lead.matcher, item));
+      });
+    else if (lead.target.isAttributeReference()) {
+      isSetPatch && result.containerType() === "primitive" && (result = result.set({}));
+      let oldValueAccessor = result.getAttribute(lead.target.name());
+      if (!oldValueAccessor && isSetPatch && (result = result.setAttribute(lead.target.name(), {}), oldValueAccessor = result.getAttribute(lead.target.name())), !oldValueAccessor)
+        return;
+      const newValueAccessor = process$1(lead.matcher, oldValueAccessor);
+      oldValueAccessor !== newValueAccessor && (result = result.setAttributeAccessor(lead.target.name(), newValueAccessor));
+    } else
+      throw new Error(`Unable to handle target ${lead.target.toString()}`);
+  }), delivery && isPatcher(delivery.payload) && (result = delivery.payload.apply(delivery.targets, result)), result;
+}
+function isPatcher(payload) {
+  return !!(payload && typeof payload == "object" && payload !== null && "apply" in payload && typeof payload.apply == "function");
+}
+const luid = uuid.uuid;
+var __defProp$3 = Object.defineProperty, __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key != "symbol" ? key + "" : key, value);
+class Mutation {
+  constructor(options) {
+    __publicField$3(this, "params"), __publicField$3(this, "compiled"), __publicField$3(this, "_appliesToMissingDocument"), this.params = options;
+  }
+  get transactionId() {
+    return this.params.transactionId;
+  }
+  get transition() {
+    return this.params.transition;
+  }
+  get identity() {
+    return this.params.identity;
+  }
+  get previousRev() {
+    return this.params.previousRev;
+  }
+  get resultRev() {
+    return this.params.resultRev;
+  }
+  get mutations() {
+    return this.params.mutations;
+  }
+  get timestamp() {
+    if (typeof this.params.timestamp == "string")
+      return new Date(this.params.timestamp);
+  }
+  get effects() {
+    return this.params.effects;
+  }
+  assignRandomTransactionId() {
+    this.params.transactionId = luid(), this.params.resultRev = this.params.transactionId;
+  }
+  appliesToMissingDocument() {
+    if (typeof this._appliesToMissingDocument < "u")
+      return this._appliesToMissingDocument;
+    const firstMut = this.mutations[0];
+    return firstMut ? this._appliesToMissingDocument = !!(firstMut.create || firstMut.createIfNotExists || firstMut.createOrReplace) : this._appliesToMissingDocument = !0, this._appliesToMissingDocument;
+  }
+  // Compiles all mutations into a handy function
+  compile() {
+    const operations = [], getGuaranteedCreatedAt = (doc) => (doc == null ? void 0 : doc._createdAt) || this.params.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    this.mutations.forEach((mutation) => {
+      if (mutation.create) {
+        const create = mutation.create || {};
+        operations.push((doc) => doc || Object.assign(create, {
+          _createdAt: getGuaranteedCreatedAt(create)
+        }));
+        return;
+      }
+      if (mutation.createIfNotExists) {
+        const createIfNotExists = mutation.createIfNotExists || {};
+        operations.push(
+          (doc) => doc === null ? Object.assign(createIfNotExists, {
+            _createdAt: getGuaranteedCreatedAt(createIfNotExists)
+          }) : doc
+        );
+        return;
+      }
+      if (mutation.createOrReplace) {
+        const createOrReplace = mutation.createOrReplace || {};
+        operations.push(
+          () => Object.assign(createOrReplace, {
+            _createdAt: getGuaranteedCreatedAt(createOrReplace)
+          })
+        );
+        return;
+      }
+      if (mutation.delete) {
+        operations.push(() => null);
+        return;
+      }
+      if (mutation.patch) {
+        if ("query" in mutation.patch)
+          return;
+        const patch = new Patcher(mutation.patch);
+        operations.push((doc) => patch.apply(doc));
+        return;
+      }
+      throw new Error(`Unsupported mutation ${JSON.stringify(mutation, null, 2)}`);
+    }), typeof this.params.timestamp == "string" && operations.push((doc) => doc ? Object.assign(doc, { _updatedAt: this.params.timestamp }) : null);
+    const prevRev = this.previousRev, rev = this.resultRev || this.transactionId;
+    this.compiled = (doc) => {
+      if (prevRev && doc && prevRev !== doc._rev)
+        throw new Error(
+          `Previous revision for this mutation was ${prevRev}, but the document revision is ${doc._rev}`
+        );
+      let result = doc;
+      for (const operation of operations)
+        result = operation(result);
+      return result && rev && (result === doc && (result = Object.assign({}, doc)), result._rev = rev), result;
+    };
+  }
+  apply(document2) {
+    debug("Applying mutation %O to document %O", this.mutations, document2), this.compiled || this.compile();
+    const result = this.compiled(document2);
+    return debug("  => %O", result), result;
+  }
+  static applyAll(document2, mutations) {
+    return mutations.reduce((doc, mutation) => mutation.apply(doc), document2);
+  }
+  // Given a number of yet-to-be-committed mutation objects, collects them into one big mutation
+  // any metadata like transactionId is ignored and must be submitted by the client. It is assumed
+  // that all mutations are on the same document.
+  // TOOO: Optimize mutations, eliminating mutations that overwrite themselves!
+  static squash(document2, mutations) {
+    const squashed = mutations.reduce(
+      (result, mutation) => result.concat(...mutation.mutations),
+      []
+    );
+    return new Mutation({ mutations: squashed });
+  }
+}
+function removeExcludedPaths(doc, schemaType) {
+  if (!sanity.isDocumentSchemaType(schemaType) || !doc)
+    return doc;
+  const pathsToExclude = extractPaths(doc, schemaType, []).filter(
+    (field) => {
+      var _a, _b, _c;
+      return ((_c = (_b = (_a = field.schemaType) == null ? void 0 : _a.options) == null ? void 0 : _b.documentInternationalization) == null ? void 0 : _c.exclude) === !0;
+    }
+  ).map((field) => sanity.pathToString(field.path));
+  return new Mutation({
+    mutations: [
+      {
+        patch: {
+          id: doc._id,
+          unset: pathsToExclude
+        }
+      }
+    ]
+  }).apply(doc);
+}
+function extractPaths(doc, schemaType, path) {
+  return schemaType.fields.reduce((acc, field) => {
+    var _a, _b;
+    const fieldPath = [...path, field.name], fieldSchema = field.type, { value } = (_a = extractWithPath(sanity.pathToString(fieldPath), doc)[0]) != null ? _a : {};
+    if (!value)
+      return acc;
+    const thisFieldWithPath = {
+      path: fieldPath,
+      name: field.name,
+      schemaType: fieldSchema,
+      value
+    };
+    if (fieldSchema.jsonType === "object") {
+      const innerFields = extractPaths(doc, fieldSchema, fieldPath);
+      return [...acc, thisFieldWithPath, ...innerFields];
+    } else if (fieldSchema.jsonType === "array" && fieldSchema.of.length && fieldSchema.of.some((item) => "fields" in item)) {
+      const { value: arrayValue } = (_b = extractWithPath(sanity.pathToString(fieldPath), doc)[0]) != null ? _b : {};
+      let arrayPaths = [];
+      if (arrayValue != null && arrayValue.length)
+        for (const item of arrayValue) {
+          const itemPath = [...fieldPath, { _key: item._key }];
+          let itemSchema = fieldSchema.of.find((t) => t.name === item._type);
+          if (item._type || (itemSchema = fieldSchema.of[0]), item._key && itemSchema) {
+            const innerFields = extractPaths(
+              doc,
+              itemSchema,
+              itemPath
+            ), arrayMember = {
+              path: itemPath,
+              name: item._key,
+              schemaType: itemSchema,
+              value: item
+            };
+            arrayPaths = [...arrayPaths, arrayMember, ...innerFields];
+          }
+        }
+      return [...acc, thisFieldWithPath, ...arrayPaths];
+    }
+    return [...acc, thisFieldWithPath];
+  }, []);
+}
+var __defProp$1 = Object.defineProperty, __defProps$1 = Object.defineProperties, __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$1 = Object.getOwnPropertySymbols, __hasOwnProp$1 = Object.prototype.hasOwnProperty, __propIsEnum$1 = Object.prototype.propertyIsEnumerable, __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b))
+      __propIsEnum$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
+  return a;
+}, __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+function LanguageOption(props) {
+  var _a;
+  const {
+    language,
+    schemaType,
+    documentId,
+    current,
+    source,
+    sourceLanguageId,
+    metadata: metadata2,
+    metadataId
+  } = props, [userHasClicked, setUserHasClicked] = react.useState(!1), disabled = props.disabled || userHasClicked || current || !source || !sourceLanguageId || !metadataId, translation = metadata2 != null && metadata2.translations.length ? metadata2.translations.find((t) => t._key === language.id) : void 0, { apiVersion, languageField, weakReferences } = useDocumentInternationalizationContext(), client = sanity.useClient({ apiVersion }), toast = ui.useToast(), open = useOpenInNewPane((_a = translation == null ? void 0 : translation.value) == null ? void 0 : _a._ref, schemaType.name), handleOpen = react.useCallback(() => open(), [open]);
+  react.useEffect(() => {
+    setUserHasClicked(!1);
+  }, [!!translation]);
+  const handleCreate = react.useCallback(async () => {
+    if (!source)
+      throw new Error("Cannot create translation without source document");
+    if (!sourceLanguageId)
+      throw new Error("Cannot create translation without source language ID");
+    if (!metadataId)
+      throw new Error("Cannot create translation without a metadata ID");
+    setUserHasClicked(!0);
+    const transaction = client.transaction(), newTranslationDocumentId = uuid.uuid();
+    let newTranslationDocument = __spreadProps$1(__spreadValues$1({}, source), {
+      _id: `drafts.${newTranslationDocumentId}`,
+      // 2. Update language of the translation
+      [languageField]: language.id
+    });
+    newTranslationDocument = removeExcludedPaths(
+      newTranslationDocument,
+      schemaType
+    ), transaction.create(newTranslationDocument);
+    const sourceReference = createReference(
+      sourceLanguageId,
+      documentId,
+      schemaType.name,
+      !weakReferences
+    ), newTranslationReference = createReference(
+      language.id,
+      newTranslationDocumentId,
+      schemaType.name,
+      !weakReferences
+    ), newMetadataDocument = {
+      _id: metadataId,
+      _type: METADATA_SCHEMA_NAME,
+      schemaTypes: [schemaType.name],
+      translations: [sourceReference]
+    };
+    transaction.createIfNotExists(newMetadataDocument);
+    const metadataPatch = client.patch(metadataId).setIfMissing({ translations: [sourceReference] }).insert("after", "translations[-1]", [newTranslationReference]);
+    transaction.patch(metadataPatch), transaction.commit().then(() => {
+      const metadataExisted = !!(metadata2 != null && metadata2._createdAt);
+      return toast.push({
+        status: "success",
+        title: `Created "${language.title}" translation`,
+        description: metadataExisted ? "Updated Translations Metadata" : "Created Translations Metadata"
+      });
+    }).catch((err) => (console.error(err), setUserHasClicked(!1), toast.push({
+      status: "error",
+      title: "Error creating translation",
+      description: err.message
+    })));
+  }, [
+    client,
+    documentId,
+    language.id,
+    language.title,
+    languageField,
+    metadata2 == null ? void 0 : metadata2._createdAt,
+    metadataId,
+    schemaType,
+    source,
+    sourceLanguageId,
+    toast,
+    weakReferences
+  ]);
+  let message;
+  return current ? message = "Current document" : translation ? message = `Open ${language.title} translation` : translation || (message = `Create new ${language.title} translation`), /* @__PURE__ */ jsxRuntime.jsx(
+    ui.Tooltip,
+    {
+      animate: !0,
+      content: /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding: 2, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { muted: !0, size: 1, children: message }) }),
+      fallbackPlacements: ["right", "left"],
       placement: "top",
       portal: !0,
       children: /* @__PURE__ */ jsxRuntime.jsx(
@@ -1425,10 +4248,17 @@ var metadata = (schemaTypes, metadataFields) => sanity.defineType({
       };
     }
   }
-});
+}), __defProp2 = Object.defineProperty, __defProps = Object.defineProperties, __getOwnPropDescs = Object.getOwnPropertyDescriptors, __getOwnPropSymbols2 = Object.getOwnPropertySymbols, __hasOwnProp2 = Object.prototype.hasOwnProperty, __propIsEnum2 = Object.prototype.propertyIsEnumerable, __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp2.call(b, prop) && __defNormalProp2(a, prop, b[prop]);
+  if (__getOwnPropSymbols2)
+    for (var prop of __getOwnPropSymbols2(b))
+      __propIsEnum2.call(b, prop) && __defNormalProp2(a, prop, b[prop]);
+  return a;
+}, __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 const documentInternationalization = sanity.definePlugin(
   (config2) => {
-    const pluginConfig = { ...DEFAULT_CONFIG, ...config2 }, {
+    const pluginConfig = __spreadValues2(__spreadValues2({}, DEFAULT_CONFIG), config2), {
       supportedLanguages,
       schemaTypes,
       languageField,
@@ -1443,7 +4273,7 @@ const documentInternationalization = sanity.definePlugin(
       name: "@sanity/document-internationalization",
       studio: {
         components: {
-          layout: (props) => DocumentInternationalizationProvider({ ...props, pluginConfig })
+          layout: (props) => DocumentInternationalizationProvider(__spreadProps(__spreadValues2({}, props), { pluginConfig }))
         }
       },
       i18n: {
@@ -1485,7 +4315,7 @@ const documentInternationalization = sanity.definePlugin(
           const { schemaType, documentId } = ctx;
           return schemaTypes.includes(schemaType) && documentId ? [
             ...prev,
-            (props) => DocumentInternationalizationMenu({ ...props, documentId })
+            (props) => DocumentInternationalizationMenu(__spreadProps(__spreadValues2({}, props), { documentId }))
           ] : prev;
         },
         badges: (prev, { schemaType }) => schemaTypes.includes(schemaType) ? [(props) => LanguageBadge(props), ...prev] : prev,
@@ -1561,14 +4391,14 @@ const documentInternationalization = sanity.definePlugin(
                 ),
                 options: {
                   // @ts-expect-error - Update type once it knows the values of this filter
-                  filter: ({ parent, document }) => {
+                  filter: ({ parent, document: document2 }) => {
                     if (!parent)
                       return null;
                     const language = (Array.isArray(parent) ? parent : [parent]).find((p) => p._key);
-                    return language != null && language._key ? document.schemaTypes ? {
+                    return language != null && language._key ? document2.schemaTypes ? {
                       filter: `_type in $schemaTypes && ${languageField} == $language`,
                       params: {
-                        schemaTypes: document.schemaTypes,
+                        schemaTypes: document2.schemaTypes,
                         language: language._key
                       }
                     } : {