@sanity/document-internationalization 3.3.0 → 3.3.2

package/dist/index.js

@@ -1,26 +1,11 @@
 "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"), 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);
+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");
 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" });
 }
-const METADATA_SCHEMA_NAME = "translation.metadata", TRANSLATIONS_ARRAY_NAME = "translations", API_VERSION = "2023-05-22", DEFAULT_CONFIG = {
+const METADATA_SCHEMA_NAME = "translation.metadata", TRANSLATIONS_ARRAY_NAME = "translations", API_VERSION = "2025-02-19", DEFAULT_CONFIG = {
   supportedLanguages: [],
   schemaTypes: [],
   languageField: "language",
@@ -149,12 +134,12 @@ function query$1(fn, keys = null, preload = !1, config2 = {}) {
     throw entry.promise;
 }
 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) => {
+var __defProp$3 = 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$3 = (obj, key, value) => key in obj ? __defProp$3(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]);
+    __hasOwnProp$3.call(b, prop) && __defNormalProp$3(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]);
+      __propIsEnum$3.call(b, prop) && __defNormalProp$3(a, prop, b[prop]);
   return a;
 }, __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
 const DocumentInternationalizationContext = react.createContext(DEFAULT_CONFIG);
@@ -285,7 +270,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$2(value) {
+function isFunction(value) {
   return typeof value == "function";
 }
 function createErrorClass(createImpl) {
@@ -338,7 +323,7 @@ var Subscription = function() {
         else
           _parentage.remove(this);
       var initialFinalizer = this.initialTeardown;
-      if (isFunction$2(initialFinalizer))
+      if (isFunction(initialFinalizer))
         try {
           initialFinalizer();
         } catch (e) {
@@ -401,10 +386,10 @@ var Subscription = function() {
   }(), Subscription2;
 }();
 function isSubscription(value) {
-  return value instanceof Subscription || value && "closed" in value && isFunction$2(value.remove) && isFunction$2(value.add) && isFunction$2(value.unsubscribe);
+  return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
 }
 function execFinalizer(finalizer) {
-  isFunction$2(finalizer) ? finalizer() : finalizer.unsubscribe();
+  isFunction(finalizer) ? finalizer() : finalizer.unsubscribe();
 }
 var config = {
   onUnhandledError: null,
@@ -500,7 +485,7 @@ var ConsumerObserver = function() {
   __extends(SafeSubscriber2, _super);
   function SafeSubscriber2(observerOrNext, error, complete) {
     var _this = _super.call(this) || this, partialObserver;
-    if (isFunction$2(observerOrNext) || !observerOrNext)
+    if (isFunction(observerOrNext) || !observerOrNext)
       partialObserver = {
         next: observerOrNext != null ? observerOrNext : void 0,
         error: error != null ? error : void 0,
@@ -533,7 +518,7 @@ var EMPTY_OBSERVER = {
   complete: noop
 };
 function hasLift(source) {
-  return isFunction$2(source == null ? void 0 : source.lift);
+  return isFunction(source == null ? void 0 : source.lift);
 }
 function operate(init) {
   return function(source) {
@@ -844,2910 +829,123 @@ function LanguageManage(props) {
     }
   );
 }
-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) {
-    }
-    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;
+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;
     }
-  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;
+  ).map((field) => sanity.pathToString(field.path));
+  return new mutator.Mutation({
+    mutations: [
+      {
+        patch: {
+          id: doc._id,
+          unset: pathsToExclude
         }
       }
-    }
-  }
-  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;
+    ]
+  }).apply(doc);
 }
-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--;
+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];
           }
-          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;
         }
-      }), typeof createDebug.init == "function" && createDebug.init(debug2), debug2;
-    }
-    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 [...acc, thisFieldWithPath, ...arrayPaths];
     }
-    return createDebug.enable(createDebug.load()), createDebug;
-  }
-  return common = setup, common;
+    return [...acc, thisFieldWithPath];
+  }, []);
 }
-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 || (() => {
+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, callback } = 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
     });
-    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;
-      }
-    };
-  }(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);
-    };
-  }(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, callback } = 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]
+    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]);
@@ -4263,17 +1461,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) => {
+}), __defProp = Object.defineProperty, __defProps = Object.defineProperties, __getOwnPropDescs = Object.getOwnPropertyDescriptors, __getOwnPropSymbols = Object.getOwnPropertySymbols, __hasOwnProp = Object.prototype.hasOwnProperty, __propIsEnum = Object.prototype.propertyIsEnumerable, __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 = {}))
-    __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]);
+    __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;
 }, __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 const documentInternationalization = sanity.definePlugin(
   (config2) => {
-    const pluginConfig = __spreadValues2(__spreadValues2({}, DEFAULT_CONFIG), config2), {
+    const pluginConfig = __spreadValues(__spreadValues({}, DEFAULT_CONFIG), config2), {
       supportedLanguages,
       schemaTypes,
       languageField,
@@ -4288,7 +1486,7 @@ const documentInternationalization = sanity.definePlugin(
       name: "@sanity/document-internationalization",
       studio: {
         components: {
-          layout: (props) => DocumentInternationalizationProvider(__spreadProps(__spreadValues2({}, props), { pluginConfig }))
+          layout: (props) => DocumentInternationalizationProvider(__spreadProps(__spreadValues({}, props), { pluginConfig }))
         }
       },
       i18n: {
@@ -4330,7 +1528,7 @@ const documentInternationalization = sanity.definePlugin(
           const { schemaType, documentId } = ctx;
           return schemaTypes.includes(schemaType) && documentId ? [
             ...prev,
-            (props) => DocumentInternationalizationMenu(__spreadProps(__spreadValues2({}, props), { documentId }))
+            (props) => DocumentInternationalizationMenu(__spreadProps(__spreadValues({}, props), { documentId }))
           ] : prev;
         },
         badges: (prev, { schemaType }) => schemaTypes.includes(schemaType) ? [(props) => LanguageBadge(props), ...prev] : prev,
@@ -4406,14 +1604,14 @@ const documentInternationalization = sanity.definePlugin(
                 ),
                 options: {
                   // @ts-expect-error - Update type once it knows the values of this filter
-                  filter: ({ parent, document: document2 }) => {
+                  filter: ({ parent, document }) => {
                     if (!parent)
                       return null;
                     const language = (Array.isArray(parent) ? parent : [parent]).find((p) => p._key);
-                    return language != null && language._key ? document2.schemaTypes ? {
+                    return language != null && language._key ? document.schemaTypes ? {
                       filter: `_type in $schemaTypes && ${languageField} == $language`,
                       params: {
-                        schemaTypes: document2.schemaTypes,
+                        schemaTypes: document.schemaTypes,
                         language: language._key
                       }
                     } : {