@sanity/document-internationalization 3.1.0 → 3.2.1

package/dist/index.mjs

@@ -1,13 +1,25 @@
+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;
+};
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
-import { TrashIcon, CogIcon, SplitVerticalIcon, CheckmarkIcon, AddIcon, EditIcon, TranslateIcon, InfoOutlineIcon } from "@sanity/icons";
-import { Flex, Spinner, Stack, Text, Card, Grid, Button, useToast, Tooltip, Box, Badge, useClickOutside, TextInput, Popover, Inline, Dialog } from "@sanity/ui";
+import { TrashIcon, CopyIcon, CogIcon, SplitVerticalIcon, CheckmarkIcon, AddIcon, EditIcon, TranslateIcon, InfoOutlineIcon } from "@sanity/icons";
+import { Flex, Spinner, Stack as Stack$1, Text, Card, Grid, Button, useToast, Tooltip, Box, Badge, useClickOutside, TextInput, Popover, Inline, Dialog } from "@sanity/ui";
 import { useMemo, useEffect, createContext, useContext, useState, useCallback } from "react";
-import { useSchema, Preview, useClient, useWorkspace, isDocumentSchemaType, pathToString, useEditState, useValidationStatus, TextWithTone, PatchEvent, unset, defineType, defineField, definePlugin, isSanityDocument } from "sanity";
+import { useSchema, Preview, useClient, useWorkspace, defineLocaleResourceBundle, useDocumentStore, useDocumentOperation, useDocumentPairPermissions, DEFAULT_STUDIO_CLIENT_OPTIONS, useTranslation, useCurrentUser, InsufficientPermissionsMessage, isDocumentSchemaType, pathToString, useEditState, useValidationStatus, TextWithTone, PatchEvent, unset, defineType, defineField, definePlugin, isSanityDocument } from "sanity";
 import { Feedback, useListeningQuery } from "sanity-plugin-utils";
 import { uuid } from "@sanity/uuid";
-import { RouterContext } from "sanity/router";
-import { usePaneRouter, useDocumentPane } from "sanity/structure";
-import { Mutation, extractWithPath } from "@sanity/mutator";
+import { useRouter, RouterContext } from "sanity/router";
+import { structureLocaleNamespace, usePaneRouter, useDocumentPane } from "sanity/structure";
+import require$$0 from "tty";
+import require$$1 from "util";
 import { styled } from "styled-components";
 import { internationalizedArray } from "sanity-plugin-internationalized-array";
 function DocumentPreview(props) {
@@ -40,9 +52,9 @@ function DeleteTranslationDialog(props) {
   );
   return useEffect(() => {
     setTranslations(translations);
-  }, [setTranslations, translations]), loading ? /* @__PURE__ */ jsx(Flex, { padding: 4, align: "center", justify: "center", children: /* @__PURE__ */ jsx(Spinner, {}) }) : /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+  }, [setTranslations, translations]), loading ? /* @__PURE__ */ jsx(Flex, { padding: 4, align: "center", justify: "center", children: /* @__PURE__ */ jsx(Spinner, {}) }) : /* @__PURE__ */ jsxs(Stack$1, { space: 4, children: [
     translations && translations.length > 0 ? /* @__PURE__ */ jsx(Text, { children: "This document is a language-specific version which other translations depend on." }) : /* @__PURE__ */ jsx(Text, { children: "This document does not have connected translations." }),
-    /* @__PURE__ */ jsx(Card, { border: !0, padding: 3, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+    /* @__PURE__ */ jsx(Card, { border: !0, padding: 3, children: /* @__PURE__ */ jsxs(Stack$1, { space: 4, children: [
       /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: translations && translations.length > 0 ? /* @__PURE__ */ jsx(Fragment, { children: "Before this document can be deleted" }) : /* @__PURE__ */ jsx(Fragment, { children: "This document can now be deleted" }) }),
       /* @__PURE__ */ jsx(DocumentPreview, { value: doc, type: doc._type }),
       translations && translations.length > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
@@ -111,207 +123,3516 @@ function shallowEqualArrays(arrA, arrB, equal = (a, b) => a === b) {
       return !1;
   return !0;
 }
-function query$1(fn, keys = null, preload = !1, config = {}) {
+function query$1(fn, keys = null, preload = !1, config2 = {}) {
   keys === null && (keys = [fn]);
   for (const entry2 of globalCache)
     if (shallowEqualArrays(keys, entry2.keys, entry2.equal)) {
       if (preload)
         return;
-      if (Object.prototype.hasOwnProperty.call(entry2, "error"))
-        throw entry2.error;
-      if (Object.prototype.hasOwnProperty.call(entry2, "response"))
-        return config.lifespan && config.lifespan > 0 && (entry2.timeout && clearTimeout(entry2.timeout), entry2.timeout = setTimeout(entry2.remove, config.lifespan)), entry2.response;
-      if (!preload)
-        throw entry2.promise;
+      if (Object.prototype.hasOwnProperty.call(entry2, "error"))
+        throw entry2.error;
+      if (Object.prototype.hasOwnProperty.call(entry2, "response"))
+        return config2.lifespan && config2.lifespan > 0 && (entry2.timeout && clearTimeout(entry2.timeout), entry2.timeout = setTimeout(entry2.remove, config2.lifespan)), entry2.response;
+      if (!preload)
+        throw entry2.promise;
+    }
+  const entry = {
+    keys,
+    equal: config2.equal,
+    remove: () => {
+      const index = globalCache.indexOf(entry);
+      index !== -1 && globalCache.splice(index, 1);
+    },
+    promise: (
+      // Execute the promise
+      (isPromise(fn) ? fn : fn(...keys)).then((response) => {
+        entry.response = response, config2.lifespan && config2.lifespan > 0 && (entry.timeout = setTimeout(entry.remove, config2.lifespan));
+      }).catch((error) => entry.error = error)
+    )
+  };
+  if (globalCache.push(entry), !preload)
+    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) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$3.call(b, prop) && __defNormalProp$i(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b))
+      __propIsEnum$3.call(b, prop) && __defNormalProp$i(a, prop, b[prop]);
+  return a;
+}, __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+const DocumentInternationalizationContext = createContext(DEFAULT_CONFIG);
+function useDocumentInternationalizationContext() {
+  return useContext(DocumentInternationalizationContext);
+}
+function DocumentInternationalizationProvider(props) {
+  const { pluginConfig } = props, client = useClient({ apiVersion: pluginConfig.apiVersion }), workspace = useWorkspace(), supportedLanguages = Array.isArray(pluginConfig.supportedLanguages) ? pluginConfig.supportedLanguages : (
+    // eslint-disable-next-line require-await
+    suspend(async () => typeof pluginConfig.supportedLanguages == "function" ? pluginConfig.supportedLanguages(client) : pluginConfig.supportedLanguages, [workspace])
+  );
+  return /* @__PURE__ */ jsx(
+    DocumentInternationalizationContext.Provider,
+    {
+      value: __spreadProps$2(__spreadValues$3({}, pluginConfig), { supportedLanguages }),
+      children: props.renderDefault(props)
+    }
+  );
+}
+const DeleteTranslationAction = (props) => {
+  const { id: documentId, published, draft } = props, doc = draft || published, { languageField } = useDocumentInternationalizationContext(), [isDialogOpen, setDialogOpen] = useState(!1), [translations, setTranslations] = useState([]), onClose = useCallback(() => setDialogOpen(!1), []), documentLanguage = doc ? doc[languageField] : null, toast = useToast(), client = useClient({ apiVersion: API_VERSION }), onProceed = useCallback(() => {
+    const tx = client.transaction();
+    let operation = "DELETE";
+    documentLanguage && translations.length > 0 ? (operation = "UNSET", translations.forEach((translation) => {
+      tx.patch(
+        translation._id,
+        (patch) => patch.unset([
+          `${TRANSLATIONS_ARRAY_NAME}[_key == "${documentLanguage}"]`
+        ])
+      );
+    })) : (tx.delete(documentId), tx.delete(`drafts.${documentId}`)), tx.commit().then(() => {
+      operation === "DELETE" && onClose(), toast.push({
+        status: "success",
+        title: operation === "UNSET" ? "Translation reference unset" : "Document deleted",
+        description: operation === "UNSET" ? "The document can now be deleted" : null
+      });
+    }).catch((err) => {
+      toast.push({
+        status: "error",
+        title: operation === "unset" ? "Failed to unset translation reference" : "Failed to delete document",
+        description: err.message
+      });
+    });
+  }, [client, documentLanguage, translations, documentId, onClose, toast]);
+  return {
+    label: "Delete translation...",
+    disabled: !doc || !documentLanguage,
+    icon: TrashIcon,
+    tone: "critical",
+    onHandle: () => {
+      setDialogOpen(!0);
+    },
+    dialog: isDialogOpen && {
+      type: "dialog",
+      onClose,
+      header: "Delete translation",
+      content: doc ? /* @__PURE__ */ jsx(
+        DeleteTranslationDialog,
+        {
+          doc,
+          documentId,
+          setTranslations
+        }
+      ) : null,
+      footer: /* @__PURE__ */ jsx(
+        DeleteTranslationFooter,
+        {
+          onClose,
+          onProceed,
+          translations
+        }
+      )
+    }
+  };
+};
+var extendStatics = function(d, b) {
+  return extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2)
+      Object.prototype.hasOwnProperty.call(b2, p) && (d2[p] = b2[p]);
+  }, extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b != "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __values(o) {
+  var s = typeof Symbol == "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m)
+    return m.call(o);
+  if (o && typeof o.length == "number")
+    return {
+      next: function() {
+        return o && i >= o.length && (o = void 0), { value: o && o[i++], done: !o };
+      }
+    };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol == "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    for (; (n === void 0 || n-- > 0) && !(r = i.next()).done; )
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      r && !r.done && (m = i.return) && m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+}
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2)
+    for (var i = 0, l = from.length, ar; i < l; i++)
+      (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) {
+  return typeof value == "function";
+}
+function createErrorClass(createImpl) {
+  var _super = function(instance) {
+    Error.call(instance), instance.stack = new Error().stack;
+  }, ctorFunc = createImpl(_super);
+  return ctorFunc.prototype = Object.create(Error.prototype), ctorFunc.prototype.constructor = ctorFunc, ctorFunc;
+}
+var UnsubscriptionError = createErrorClass(function(_super) {
+  return function(errors) {
+    _super(this), this.message = errors ? errors.length + ` errors occurred during unsubscription:
+` + errors.map(function(err, i) {
+      return i + 1 + ") " + err.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = errors;
+  };
+});
+function arrRemove(arr, item) {
+  if (arr) {
+    var index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
+  }
+}
+var Subscription = function() {
+  function Subscription2(initialTeardown) {
+    this.initialTeardown = initialTeardown, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return Subscription2.prototype.unsubscribe = function() {
+    var e_1, _a, e_2, _b, errors;
+    if (!this.closed) {
+      this.closed = !0;
+      var _parentage = this._parentage;
+      if (_parentage)
+        if (this._parentage = null, Array.isArray(_parentage))
+          try {
+            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+              var parent_1 = _parentage_1_1.value;
+              parent_1.remove(this);
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              _parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return) && _a.call(_parentage_1);
+            } finally {
+              if (e_1)
+                throw e_1.error;
+            }
+          }
+        else
+          _parentage.remove(this);
+      var initialFinalizer = this.initialTeardown;
+      if (isFunction$2(initialFinalizer))
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = e instanceof UnsubscriptionError ? e.errors : [e];
+        }
+      var _finalizers = this._finalizers;
+      if (_finalizers) {
+        this._finalizers = null;
+        try {
+          for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+            var finalizer = _finalizers_1_1.value;
+            try {
+              execFinalizer(finalizer);
+            } catch (err) {
+              errors = errors != null ? errors : [], err instanceof UnsubscriptionError ? errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors)) : errors.push(err);
+            }
+          }
+        } catch (e_2_1) {
+          e_2 = { error: e_2_1 };
+        } finally {
+          try {
+            _finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return) && _b.call(_finalizers_1);
+          } finally {
+            if (e_2)
+              throw e_2.error;
+          }
+        }
+      }
+      if (errors)
+        throw new UnsubscriptionError(errors);
+    }
+  }, Subscription2.prototype.add = function(teardown) {
+    var _a;
+    if (teardown && teardown !== this)
+      if (this.closed)
+        execFinalizer(teardown);
+      else {
+        if (teardown instanceof Subscription2) {
+          if (teardown.closed || teardown._hasParent(this))
+            return;
+          teardown._addParent(this);
+        }
+        (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+      }
+  }, Subscription2.prototype._hasParent = function(parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  }, Subscription2.prototype._addParent = function(parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+  }, Subscription2.prototype._removeParent = function(parent) {
+    var _parentage = this._parentage;
+    _parentage === parent ? this._parentage = null : Array.isArray(_parentage) && arrRemove(_parentage, parent);
+  }, Subscription2.prototype.remove = function(teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown), teardown instanceof Subscription2 && teardown._removeParent(this);
+  }, Subscription2.EMPTY = function() {
+    var empty = new Subscription2();
+    return empty.closed = !0, empty;
+  }(), Subscription2;
+}();
+function isSubscription(value) {
+  return value instanceof Subscription || value && "closed" in value && isFunction$2(value.remove) && isFunction$2(value.add) && isFunction$2(value.unsubscribe);
+}
+function execFinalizer(finalizer) {
+  isFunction$2(finalizer) ? finalizer() : finalizer.unsubscribe();
+}
+var config = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: !1,
+  useDeprecatedNextContext: !1
+}, timeoutProvider = {
+  setTimeout: function(handler, timeout) {
+    for (var args = [], _i = 2; _i < arguments.length; _i++)
+      args[_i - 2] = arguments[_i];
+    return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+  },
+  clearTimeout: function(handle) {
+    return clearTimeout(handle);
+  },
+  delegate: void 0
+};
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function() {
+    throw err;
+  });
+}
+function noop() {
+}
+var Subscriber = function(_super) {
+  __extends(Subscriber2, _super);
+  function Subscriber2(destination) {
+    var _this = _super.call(this) || this;
+    return _this.isStopped = !1, destination ? (_this.destination = destination, isSubscription(destination) && destination.add(_this)) : _this.destination = EMPTY_OBSERVER, _this;
+  }
+  return Subscriber2.create = function(next, error, complete) {
+    return new SafeSubscriber(next, error, complete);
+  }, Subscriber2.prototype.next = function(value) {
+    this.isStopped || this._next(value);
+  }, Subscriber2.prototype.error = function(err) {
+    this.isStopped || (this.isStopped = !0, this._error(err));
+  }, Subscriber2.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, Subscriber2.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, _super.prototype.unsubscribe.call(this), this.destination = null);
+  }, Subscriber2.prototype._next = function(value) {
+    this.destination.next(value);
+  }, Subscriber2.prototype._error = function(err) {
+    try {
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
+    }
+  }, Subscriber2.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, Subscriber2;
+}(Subscription), _bind = Function.prototype.bind;
+function bind(fn, thisArg) {
+  return _bind.call(fn, thisArg);
+}
+var ConsumerObserver = function() {
+  function ConsumerObserver2(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  return ConsumerObserver2.prototype.next = function(value) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.next)
+      try {
+        partialObserver.next(value);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+  }, ConsumerObserver2.prototype.error = function(err) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.error)
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    else
+      handleUnhandledError(err);
+  }, ConsumerObserver2.prototype.complete = function() {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete)
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+  }, ConsumerObserver2;
+}(), SafeSubscriber = function(_super) {
+  __extends(SafeSubscriber2, _super);
+  function SafeSubscriber2(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this, partialObserver;
+    if (isFunction$2(observerOrNext) || !observerOrNext)
+      partialObserver = {
+        next: observerOrNext != null ? observerOrNext : void 0,
+        error: error != null ? error : void 0,
+        complete: complete != null ? complete : void 0
+      };
+    else {
+      var context_1;
+      _this && config.useDeprecatedNextContext ? (context_1 = Object.create(observerOrNext), context_1.unsubscribe = function() {
+        return _this.unsubscribe();
+      }, partialObserver = {
+        next: observerOrNext.next && bind(observerOrNext.next, context_1),
+        error: observerOrNext.error && bind(observerOrNext.error, context_1),
+        complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
+      }) : partialObserver = observerOrNext;
+    }
+    return _this.destination = new ConsumerObserver(partialObserver), _this;
+  }
+  return SafeSubscriber2;
+}(Subscriber);
+function handleUnhandledError(error) {
+  reportUnhandledError(error);
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+var EMPTY_OBSERVER = {
+  closed: !0,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+function hasLift(source) {
+  return isFunction$2(source == null ? void 0 : source.lift);
+}
+function operate(init) {
+  return function(source) {
+    if (hasLift(source))
+      return source.lift(function(liftedSource) {
+        try {
+          return init(liftedSource, this);
+        } catch (err) {
+          this.error(err);
+        }
+      });
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+  return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = function(_super) {
+  __extends(OperatorSubscriber2, _super);
+  function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+    var _this = _super.call(this, destination) || this;
+    return _this.onFinalize = onFinalize, _this.shouldUnsubscribe = shouldUnsubscribe, _this._next = onNext ? function(value) {
+      try {
+        onNext(value);
+      } catch (err) {
+        destination.error(err);
+      }
+    } : _super.prototype._next, _this._error = onError ? function(err) {
+      try {
+        onError(err);
+      } catch (err2) {
+        destination.error(err2);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._error, _this._complete = onComplete ? function() {
+      try {
+        onComplete();
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._complete, _this;
+  }
+  return OperatorSubscriber2.prototype.unsubscribe = function() {
+    var _a;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var closed_1 = this.closed;
+      _super.prototype.unsubscribe.call(this), !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 || _a.call(this));
+    }
+  }, OperatorSubscriber2;
+}(Subscriber), EmptyError = createErrorClass(function(_super) {
+  return function() {
+    _super(this), this.name = "EmptyError", this.message = "no elements in sequence";
+  };
+});
+function firstValueFrom(source, config2) {
+  return new Promise(function(resolve, reject) {
+    var subscriber = new SafeSubscriber({
+      next: function(value) {
+        resolve(value), subscriber.unsubscribe();
+      },
+      error: reject,
+      complete: function() {
+        reject(new EmptyError());
+      }
+    });
+    source.subscribe(subscriber);
+  });
+}
+function filter(predicate, thisArg) {
+  return operate(function(source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      return predicate.call(thisArg, value, index++) && subscriber.next(value);
+    }));
+  });
+}
+const query = `*[_type == $translationSchema && $id in translations[].value._ref]{
+  _id,
+  _createdAt,
+  translations
+}`;
+function useTranslationMetadata(id) {
+  const { data, loading, error } = useListeningQuery(query, {
+    params: { id, translationSchema: METADATA_SCHEMA_NAME }
+  });
+  return { data, loading, error };
+}
+const documenti18nLocaleNamespace = "document-internationalization", documentInternationalizationUsEnglishLocaleBundle = defineLocaleResourceBundle({
+  locale: "en-US",
+  namespace: documenti18nLocaleNamespace,
+  resources: () => import("./_chunks-es/resources.mjs")
+}), DISABLED_REASON_KEY = {
+  METADATA_NOT_FOUND: "action.duplicate.disabled.missing-metadata",
+  MULTIPLE_METADATA: "action.duplicate.disabled.multiple-metadata",
+  NOTHING_TO_DUPLICATE: "action.duplicate.disabled.nothing-to-duplicate",
+  NOT_READY: "action.duplicate.disabled.not-ready"
+}, DuplicateWithTranslationsAction = ({
+  id,
+  type,
+  onComplete
+}) => {
+  const documentStore = useDocumentStore(), { duplicate } = useDocumentOperation(id, type), { navigateIntent } = useRouter(), [isDuplicating, setDuplicating] = useState(!1), [permissions, isPermissionsLoading] = useDocumentPairPermissions({
+    id,
+    type,
+    permission: "duplicate"
+  }), { data, loading: isMetadataDocumentLoading } = useTranslationMetadata(id), hasOneMetadataDocument = useMemo(() => Array.isArray(data) && data.length <= 1, [data]), metadataDocument = Array.isArray(data) && data.length ? data[0] : null, client = useClient(DEFAULT_STUDIO_CLIENT_OPTIONS), toast = useToast(), { t: s } = useTranslation(structureLocaleNamespace), { t: d } = useTranslation(documenti18nLocaleNamespace), currentUser = useCurrentUser(), handle = useCallback(async () => {
+    setDuplicating(!0);
+    try {
+      if (!metadataDocument)
+        throw new Error("Metadata document not found");
+      const translations = /* @__PURE__ */ new Map();
+      await Promise.all(
+        metadataDocument[TRANSLATIONS_ARRAY_NAME].map(async (translation) => {
+          var _a;
+          const dupeId2 = uuid(), locale = translation._key, docId = (_a = translation.value) == null ? void 0 : _a._ref;
+          if (!docId)
+            throw new Error("Translation document not found");
+          const { duplicate: duplicateTranslation } = await firstValueFrom(
+            documentStore.pair.editOperations(docId, type).pipe(filter((op) => op.duplicate.disabled !== "NOT_READY"))
+          );
+          if (duplicateTranslation.disabled)
+            throw new Error("Cannot duplicate document");
+          const duplicateTranslationSuccess = firstValueFrom(
+            documentStore.pair.operationEvents(docId, type).pipe(filter((e) => e.op === "duplicate" && e.type === "success"))
+          );
+          duplicateTranslation.execute(dupeId2), await duplicateTranslationSuccess, translations.set(locale, dupeId2);
+        })
+      );
+      const { duplicate: duplicateMetadata } = await firstValueFrom(
+        documentStore.pair.editOperations(metadataDocument._id, METADATA_SCHEMA_NAME).pipe(filter((op) => op.duplicate.disabled !== "NOT_READY"))
+      );
+      if (duplicateMetadata.disabled)
+        throw new Error("Cannot duplicate document");
+      const duplicateMetadataSuccess = firstValueFrom(
+        documentStore.pair.operationEvents(metadataDocument._id, METADATA_SCHEMA_NAME).pipe(filter((e) => e.op === "duplicate" && e.type === "success"))
+      ), dupeId = uuid();
+      duplicateMetadata.execute(dupeId), await duplicateMetadataSuccess;
+      const patch = {
+        set: Object.fromEntries(
+          Array.from(translations.entries()).map(([locale, documentId]) => [
+            `${TRANSLATIONS_ARRAY_NAME}[_key == "${locale}"].value._ref`,
+            documentId
+          ])
+        )
+      };
+      await client.transaction().patch(dupeId, patch).commit(), navigateIntent("edit", {
+        id: Array.from(translations.values()).at(0),
+        type
+      }), onComplete();
+    } catch (error) {
+      console.error(error), toast.push({
+        status: "error",
+        title: "Error duplicating document",
+        description: error instanceof Error ? error.message : "Failed to duplicate document"
+      });
+    } finally {
+      setDuplicating(!1);
+    }
+  }, [
+    client,
+    documentStore.pair,
+    metadataDocument,
+    navigateIntent,
+    onComplete,
+    toast,
+    type
+  ]);
+  return useMemo(() => !isPermissionsLoading && !(permissions != null && permissions.granted) ? {
+    icon: CopyIcon,
+    disabled: !0,
+    label: d("action.duplicate.label"),
+    title: /* @__PURE__ */ jsx(
+      InsufficientPermissionsMessage,
+      {
+        context: "duplicate-document",
+        currentUser
+      }
+    )
+  } : !isMetadataDocumentLoading && !metadataDocument ? {
+    icon: CopyIcon,
+    disabled: !0,
+    label: d("action.duplicate.label"),
+    title: d(DISABLED_REASON_KEY.METADATA_NOT_FOUND)
+  } : hasOneMetadataDocument ? {
+    icon: CopyIcon,
+    disabled: isDuplicating || !!duplicate.disabled || isPermissionsLoading || isMetadataDocumentLoading,
+    label: isDuplicating ? s("action.duplicate.running.label") : d("action.duplicate.label"),
+    title: duplicate.disabled ? s(DISABLED_REASON_KEY[duplicate.disabled]) : "",
+    onHandle: handle
+  } : {
+    icon: CopyIcon,
+    disabled: !0,
+    label: d("action.duplicate.label"),
+    title: d(DISABLED_REASON_KEY.MULTIPLE_METADATA)
+  }, [
+    currentUser,
+    duplicate.disabled,
+    handle,
+    hasOneMetadataDocument,
+    isDuplicating,
+    isMetadataDocumentLoading,
+    isPermissionsLoading,
+    metadataDocument,
+    permissions == null ? void 0 : permissions.granted,
+    s,
+    d
+  ]);
+};
+DuplicateWithTranslationsAction.action = "duplicate";
+DuplicateWithTranslationsAction.displayName = "DuplicateWithTranslationsAction";
+function useOpenInNewPane(id, type) {
+  const routerContext = useContext(RouterContext), { routerPanesState, groupIndex } = usePaneRouter();
+  return useCallback(() => {
+    if (!routerContext || !id || !type)
+      return;
+    if (!routerPanesState.length) {
+      routerContext.navigateIntent("edit", { id, type });
+      return;
+    }
+    const panes = [...routerPanesState];
+    panes.splice(groupIndex + 1, 0, [
+      {
+        id,
+        params: { type }
+      }
+    ]);
+    const href = routerContext.resolvePathFromState({ panes });
+    routerContext.navigateUrl({ path: href });
+  }, [id, type, routerContext, routerPanesState, groupIndex]);
+}
+var __defProp$2 = Object.defineProperty, __getOwnPropSymbols$2 = Object.getOwnPropertySymbols, __hasOwnProp$2 = Object.prototype.hasOwnProperty, __propIsEnum$2 = Object.prototype.propertyIsEnumerable, __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b))
+      __propIsEnum$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
+  return a;
+};
+function createReference(key, ref, type, strengthenOnPublish = !0) {
+  return {
+    _key: key,
+    _type: "internationalizedArrayReferenceValue",
+    value: __spreadValues$2({
+      _type: "reference",
+      _ref: ref,
+      _weak: !0
+    }, strengthenOnPublish ? { _strengthenOnPublish: { type } } : {})
+  };
+}
+function LanguageManage(props) {
+  const { id, metadataId, schemaType, documentId, sourceLanguageId } = props, open = useOpenInNewPane(id, METADATA_SCHEMA_NAME), openCreated = useOpenInNewPane(metadataId, METADATA_SCHEMA_NAME), { allowCreateMetaDoc, apiVersion, weakReferences } = useDocumentInternationalizationContext(), client = useClient({ apiVersion }), [userHasClicked, setUserHasClicked] = useState(!1), canCreate = !id && !!metadataId && allowCreateMetaDoc, handleClick = useCallback(() => {
+    if (!id && metadataId && sourceLanguageId) {
+      setUserHasClicked(!0);
+      const transaction = client.transaction(), sourceReference = createReference(
+        sourceLanguageId,
+        documentId,
+        schemaType.name,
+        !weakReferences
+      ), newMetadataDocument = {
+        _id: metadataId,
+        _type: METADATA_SCHEMA_NAME,
+        schemaTypes: [schemaType.name],
+        translations: [sourceReference]
+      };
+      transaction.createIfNotExists(newMetadataDocument), transaction.commit().then(() => {
+        setUserHasClicked(!1), openCreated();
+      }).catch((err) => {
+        console.error(err), setUserHasClicked(!1);
+      });
+    } else
+      open();
+  }, [
+    id,
+    metadataId,
+    sourceLanguageId,
+    client,
+    documentId,
+    schemaType.name,
+    weakReferences,
+    openCreated,
+    open
+  ]);
+  return /* @__PURE__ */ jsx(
+    Tooltip,
+    {
+      animate: !0,
+      content: /* @__PURE__ */ jsx(Box, { padding: 2, children: /* @__PURE__ */ jsx(Text, { muted: !0, size: 1, children: "Document has no other translations" }) }),
+      fallbackPlacements: ["right", "left"],
+      placement: "top",
+      portal: !0,
+      disabled: !!id || canCreate,
+      children: /* @__PURE__ */ jsx(Stack$1, { children: /* @__PURE__ */ jsx(
+        Button,
+        {
+          disabled: !id && !canCreate || canCreate && !sourceLanguageId || userHasClicked,
+          mode: "ghost",
+          text: "Manage Translations",
+          icon: CogIcon,
+          loading: userHasClicked,
+          onClick: handleClick
+        }
+      ) })
+    }
+  );
+}
+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(module, exports) {
+  var root2 = _root, stubFalse2 = stubFalse_1, freeExports = exports && !exports.nodeType && exports, freeModule = freeExports && !0 && module && !module.nodeType && module, moduleExports = freeModule && freeModule.exports === freeExports, Buffer2 = moduleExports ? root2.Buffer : void 0, nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0, isBuffer2 = nativeIsBuffer || stubFalse2;
+  module.exports = isBuffer2;
+})(isBuffer, isBuffer.exports);
+var _nodeUtil = { exports: {} };
+(function(module, exports) {
+  var freeGlobal2 = _freeGlobal, freeExports = exports && !exports.nodeType && exports, freeModule = freeExports && !0 && module && !module.nodeType && module, 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) {
+    }
+  }();
+  module.exports = nodeUtil;
+})(_nodeUtil, _nodeUtil.exports);
+var getNative$3 = _getNative, root$3 = _root, DataView$1 = getNative$3(root$3, "DataView"), _DataView = DataView$1, getNative$2 = _getNative, root$2 = _root, Promise$2 = getNative$2(root$2, "Promise"), _Promise = Promise$2, getNative$1 = _getNative, root$1 = _root, Set$2 = getNative$1(root$1, "Set"), _Set = Set$2, getNative = _getNative, root = _root, WeakMap$1 = getNative(root, "WeakMap"), _WeakMap = WeakMap$1, DataView = _DataView, Map$1 = _Map, Promise$1 = _Promise, Set$1 = _Set, WeakMap = _WeakMap, baseGetTag$1 = _baseGetTag, toSource = _toSource, mapTag = "[object Map]", objectTag = "[object Object]", promiseTag = "[object Promise]", setTag = "[object Set]", weakMapTag = "[object WeakMap]", dataViewTag = "[object DataView]", dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$1), weakMapCtorString = toSource(WeakMap), getTag = baseGetTag$1;
+(DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map$1 && getTag(new Map$1()) != mapTag || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set$1 && getTag(new Set$1()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) && (getTag = function(value) {
+  var result = baseGetTag$1(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+  if (ctorString)
+    switch (ctorString) {
+      case dataViewCtorString:
+        return dataViewTag;
+      case mapCtorString:
+        return mapTag;
+      case promiseCtorString:
+        return promiseTag;
+      case setCtorString:
+        return setTag;
+      case weakMapCtorString:
+        return weakMapTag;
+    }
+  return result;
+});
+var src = { exports: {} }, browser$1 = { exports: {} }, ms, hasRequiredMs;
+function requireMs() {
+  if (hasRequiredMs)
+    return ms;
+  hasRequiredMs = 1;
+  var s = 1e3, m = s * 60, h = m * 60, d = h * 24, w = d * 7, y = d * 365.25;
+  ms = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0)
+      return parse2(val);
+    if (type === "number" && isFinite(val))
+      return options.long ? fmtLong(val) : fmtShort(val);
+    throw new Error(
+      "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+    );
+  };
+  function parse2(str) {
+    if (str = String(str), !(str.length > 100)) {
+      var match2 = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (match2) {
+        var n = parseFloat(match2[1]), type = (match2[2] || "ms").toLowerCase();
+        switch (type) {
+          case "years":
+          case "year":
+          case "yrs":
+          case "yr":
+          case "y":
+            return n * y;
+          case "weeks":
+          case "week":
+          case "w":
+            return n * w;
+          case "days":
+          case "day":
+          case "d":
+            return n * d;
+          case "hours":
+          case "hour":
+          case "hrs":
+          case "hr":
+          case "h":
+            return n * h;
+          case "minutes":
+          case "minute":
+          case "mins":
+          case "min":
+          case "m":
+            return n * m;
+          case "seconds":
+          case "second":
+          case "secs":
+          case "sec":
+          case "s":
+            return n * s;
+          case "milliseconds":
+          case "millisecond":
+          case "msecs":
+          case "msec":
+          case "ms":
+            return n;
+          default:
+            return;
+        }
+      }
+    }
+  }
+  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;
+}
+var common, hasRequiredCommon;
+function requireCommon() {
+  if (hasRequiredCommon)
+    return common;
+  hasRequiredCommon = 1;
+  function setup(env) {
+    createDebug.debug = createDebug, createDebug.default = createDebug, createDebug.coerce = coerce, createDebug.disable = disable, createDebug.enable = enable, createDebug.enabled = enabled, createDebug.humanize = requireMs(), createDebug.destroy = destroy, Object.keys(env).forEach((key) => {
+      createDebug[key] = env[key];
+    }), createDebug.names = [], createDebug.skips = [], createDebug.formatters = {};
+    function selectColor(namespace) {
+      let hash = 0;
+      for (let i = 0; i < namespace.length; i++)
+        hash = (hash << 5) - hash + namespace.charCodeAt(i), hash |= 0;
+      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+    }
+    createDebug.selectColor = selectColor;
+    function createDebug(namespace) {
+      let prevTime, enableOverride = null, namespacesCache, enabledCache;
+      function debug2(...args) {
+        if (!debug2.enabled)
+          return;
+        const self2 = debug2, curr = Number(/* @__PURE__ */ new Date()), ms2 = curr - (prevTime || curr);
+        self2.diff = ms2, self2.prev = prevTime, self2.curr = curr, prevTime = curr, args[0] = createDebug.coerce(args[0]), typeof args[0] != "string" && args.unshift("%O");
+        let index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match2, format) => {
+          if (match2 === "%%")
+            return "%";
+          index++;
+          const formatter = createDebug.formatters[format];
+          if (typeof formatter == "function") {
+            const val = args[index];
+            match2 = formatter.call(self2, val), args.splice(index, 1), index--;
+          }
+          return match2;
+        }), createDebug.formatArgs.call(self2, args), (self2.log || createDebug.log).apply(self2, args);
+      }
+      return debug2.namespace = namespace, debug2.useColors = createDebug.useColors(), debug2.color = createDebug.selectColor(namespace), debug2.extend = extend, debug2.destroy = createDebug.destroy, Object.defineProperty(debug2, "enabled", {
+        enumerable: !0,
+        configurable: !1,
+        get: () => enableOverride !== null ? enableOverride : (namespacesCache !== createDebug.namespaces && (namespacesCache = createDebug.namespaces, enabledCache = createDebug.enabled(namespace)), enabledCache),
+        set: (v) => {
+          enableOverride = v;
+        }
+      }), 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 createDebug.enable(createDebug.load()), createDebug;
+  }
+  return common = setup, common;
+}
+var hasRequiredBrowser$1;
+function requireBrowser$1() {
+  return hasRequiredBrowser$1 || (hasRequiredBrowser$1 = 1, function(module, exports) {
+    exports.formatArgs = formatArgs, exports.save = save, exports.load = load, exports.useColors = useColors, exports.storage = localstorage(), exports.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`."));
+      };
+    })(), exports.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 " : " ") + "+" + module.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);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        namespaces ? exports.storage.setItem("debug", namespaces) : exports.storage.removeItem("debug");
+      } catch (error) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports.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) {
+      }
+    }
+    module.exports = requireCommon()(exports);
+    const { formatters } = module.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(module, exports) {
+    const tty = require$$0, util = require$$1;
+    exports.init = init, exports.log = log, exports.formatArgs = formatArgs, exports.save = save, exports.load = load, exports.useColors = useColors, exports.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`."
+    ), exports.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      const supportsColor = requireBrowser();
+      supportsColor && (supportsColor.stderr || supportsColor).level >= 2 && (exports.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) {
+    }
+    exports.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 exports.inspectOpts ? !!exports.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+" + module.exports.humanize(this.diff) + "\x1B[0m");
+      } else
+        args[0] = getDate() + name + " " + args[0];
+    }
+    function getDate() {
+      return exports.inspectOpts.hideDate ? "" : (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util.formatWithOptions(exports.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(exports.inspectOpts);
+      for (let i = 0; i < keys.length; i++)
+        debug2.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+    }
+    module.exports = requireCommon()(exports);
+    const { formatters } = module.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
+          });
+        });
     }
-  const entry = {
-    keys,
-    equal: config.equal,
-    remove: () => {
-      const index = globalCache.indexOf(entry);
-      index !== -1 && globalCache.splice(index, 1);
-    },
-    promise: (
-      // Execute the promise
-      (isPromise(fn) ? fn : fn(...keys)).then((response) => {
-        entry.response = response, config.lifespan && config.lifespan > 0 && (entry.timeout = setTimeout(entry.remove, config.lifespan));
-      }).catch((error) => entry.error = error)
-    )
-  };
-  if (globalCache.push(entry), !preload)
-    throw entry.promise;
+    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());
+  }
 }
-const suspend = (fn, keys, config) => query$1(fn, keys, !1, config), DocumentInternationalizationContext = createContext(DEFAULT_CONFIG);
-function useDocumentInternationalizationContext() {
-  return useContext(DocumentInternationalizationContext);
+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 DocumentInternationalizationProvider(props) {
-  const { pluginConfig } = props, client = useClient({ apiVersion: pluginConfig.apiVersion }), workspace = useWorkspace(), supportedLanguages = Array.isArray(pluginConfig.supportedLanguages) ? pluginConfig.supportedLanguages : (
-    // eslint-disable-next-line require-await
-    suspend(async () => typeof pluginConfig.supportedLanguages == "function" ? pluginConfig.supportedLanguages(client) : pluginConfig.supportedLanguages, [workspace])
-  );
-  return /* @__PURE__ */ jsx(
-    DocumentInternationalizationContext.Provider,
-    {
-      value: { ...pluginConfig, supportedLanguages },
-      children: props.renderDefault(props)
-    }
-  );
+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;
 }
-const DeleteTranslationAction = (props) => {
-  const { id: documentId, published, draft } = props, doc = draft || published, { languageField } = useDocumentInternationalizationContext(), [isDialogOpen, setDialogOpen] = useState(!1), [translations, setTranslations] = useState([]), onClose = useCallback(() => setDialogOpen(!1), []), documentLanguage = doc ? doc[languageField] : null, toast = useToast(), client = useClient({ apiVersion: API_VERSION }), onProceed = useCallback(() => {
-    const tx = client.transaction();
-    let operation = "DELETE";
-    documentLanguage && translations.length > 0 ? (operation = "UNSET", translations.forEach((translation) => {
-      tx.patch(
-        translation._id,
-        (patch) => patch.unset([
-          `${TRANSLATIONS_ARRAY_NAME}[_key == "${documentLanguage}"]`
-        ])
-      );
-    })) : (tx.delete(documentId), tx.delete(`drafts.${documentId}`)), tx.commit().then(() => {
-      operation === "DELETE" && onClose(), toast.push({
-        status: "success",
-        title: operation === "UNSET" ? "Translation reference unset" : "Document deleted",
-        description: operation === "UNSET" ? "The document can now be deleted" : null
-      });
-    }).catch((err) => {
-      toast.push({
-        status: "error",
-        title: operation === "unset" ? "Failed to unset translation reference" : "Failed to delete document",
-        description: err.message
-      });
+function descend(matcher, accessor) {
+  const { leads, delivery } = matcher.match(accessor);
+  leads.forEach((lead) => {
+    accessorsFromTarget(lead.target, accessor).forEach((childAccessor) => {
+      descend(lead.matcher, childAccessor);
     });
-  }, [client, documentLanguage, translations, documentId, onClose, toast]);
-  return {
-    label: "Delete translation...",
-    disabled: !doc || !documentLanguage,
-    icon: TrashIcon,
-    tone: "critical",
-    onHandle: () => {
-      setDialogOpen(!0);
-    },
-    dialog: isDialogOpen && {
-      type: "dialog",
-      onClose,
-      header: "Delete translation",
-      content: doc ? /* @__PURE__ */ jsx(
-        DeleteTranslationDialog,
-        {
-          doc,
-          documentId,
-          setTranslations
-        }
-      ) : null,
-      footer: /* @__PURE__ */ jsx(
-        DeleteTranslationFooter,
-        {
-          onClose,
-          onProceed,
-          translations
+  }), 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()}`);
     }
-  };
-}, query = `*[_type == $translationSchema && $id in translations[].value._ref]{
-  _id,
-  _createdAt,
-  translations
-}`;
-function useTranslationMetadata(id) {
-  const { data, loading, error } = useListeningQuery(query, {
-    params: { id, translationSchema: METADATA_SCHEMA_NAME }
-  });
-  return { data, loading, error };
+    return result;
+  }
 }
-function useOpenInNewPane(id, type) {
-  const routerContext = useContext(RouterContext), { routerPanesState, groupIndex } = usePaneRouter();
-  return useCallback(() => {
-    if (!routerContext || !id || !type)
-      return;
-    if (!routerPanesState.length) {
-      routerContext.navigateIntent("edit", { id, type });
-      return;
+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()}`);
     }
-    const panes = [...routerPanesState];
-    panes.splice(groupIndex + 1, 0, [
-      {
-        id,
-        params: { type }
+    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;
       }
-    ]);
-    const href = routerContext.resolvePathFromState({ panes });
-    routerContext.navigateUrl({ path: href });
-  }, [id, type, routerContext, routerPanesState, groupIndex]);
+      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 createReference(key, ref, type, strengthenOnPublish = !0) {
-  return {
-    _key: key,
-    _type: "internationalizedArrayReferenceValue",
-    value: {
-      _type: "reference",
-      _ref: ref,
-      _weak: !0,
-      // If the user has configured weakReferences, we won't want to strengthen them
-      ...strengthenOnPublish ? { _strengthenOnPublish: { type } } : {}
+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 LanguageManage(props) {
-  const { id, metadataId, schemaType, documentId, sourceLanguageId } = props, open = useOpenInNewPane(id, METADATA_SCHEMA_NAME), openCreated = useOpenInNewPane(metadataId, METADATA_SCHEMA_NAME), { allowCreateMetaDoc, apiVersion, weakReferences } = useDocumentInternationalizationContext(), client = useClient({ apiVersion }), [userHasClicked, setUserHasClicked] = useState(!1), canCreate = !id && !!metadataId && allowCreateMetaDoc, handleClick = useCallback(() => {
-    if (!id && metadataId && sourceLanguageId) {
-      setUserHasClicked(!0);
-      const transaction = client.transaction(), sourceReference = createReference(
-        sourceLanguageId,
-        documentId,
-        schemaType.name,
-        !weakReferences
-      ), newMetadataDocument = {
-        _id: metadataId,
-        _type: METADATA_SCHEMA_NAME,
-        schemaTypes: [schemaType.name],
-        translations: [sourceReference]
-      };
-      transaction.createIfNotExists(newMetadataDocument), transaction.commit().then(() => {
-        setUserHasClicked(!1), openCreated();
-      }).catch((err) => {
-        console.error(err), setUserHasClicked(!1);
+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: unset2, 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]));
+  }), unset2 && unset2.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
-      open();
-  }, [
-    id,
-    metadataId,
-    sourceLanguageId,
-    client,
-    documentId,
-    schemaType.name,
-    weakReferences,
-    openCreated,
-    open
-  ]);
-  return /* @__PURE__ */ jsx(
-    Tooltip,
-    {
-      animate: !0,
-      content: /* @__PURE__ */ jsx(Box, { padding: 2, children: /* @__PURE__ */ jsx(Text, { muted: !0, size: 1, children: "Document has no other translations" }) }),
-      fallbackPlacements: ["right", "left"],
-      placement: "top",
-      portal: !0,
-      disabled: !!id || canCreate,
-      children: /* @__PURE__ */ jsx(Stack, { children: /* @__PURE__ */ jsx(
-        Button,
-        {
-          disabled: !id && !canCreate || canCreate && !sourceLanguageId || userHasClicked,
-          mode: "ghost",
-          text: "Manage Translations",
-          icon: CogIcon,
-          loading: userHasClicked,
-          onClick: handleClick
-        }
-      ) })
-    }
-  );
+      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;
+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 (!isDocumentSchemaType(schemaType) || !doc)
@@ -374,6 +3695,14 @@ function extractPaths(doc, schemaType, path) {
     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 {
@@ -398,12 +3727,11 @@ function LanguageOption(props) {
       throw new Error("Cannot create translation without a metadata ID");
     setUserHasClicked(!0);
     const transaction = client.transaction(), newTranslationDocumentId = uuid();
-    let newTranslationDocument = {
-      ...source,
+    let newTranslationDocument = __spreadProps$1(__spreadValues$1({}, source), {
       _id: `drafts.${newTranslationDocumentId}`,
       // 2. Update language of the translation
       [languageField]: language.id
-    };
+    });
     newTranslationDocument = removeExcludedPaths(
       newTranslationDocument,
       schemaType
@@ -529,7 +3857,7 @@ function DocumentInternationalizationMenu(props) {
       'Not all languages are valid. It should be an array of objects with an "id" and "title" property. Or a function that returns an array of objects with an "id" and "title" property.',
       supportedLanguages
     ), valid;
-  }, [supportedLanguages]), content = /* @__PURE__ */ jsx(Box, { padding: 1, children: error ? /* @__PURE__ */ jsx(Card, { tone: "critical", padding: 1, children: /* @__PURE__ */ jsx(Text, { children: "There was an error returning translations metadata" }) }) : /* @__PURE__ */ jsxs(Stack, { space: 1, children: [
+  }, [supportedLanguages]), content = /* @__PURE__ */ jsx(Box, { padding: 1, children: error ? /* @__PURE__ */ jsx(Card, { tone: "critical", padding: 1, children: /* @__PURE__ */ jsx(Text, { children: "There was an error returning translations metadata" }) }) : /* @__PURE__ */ jsxs(Stack$1, { space: 1, children: [
     /* @__PURE__ */ jsx(
       LanguageManage,
       {
@@ -736,7 +4064,7 @@ function InfoIcon(props) {
   );
 }
 function Info() {
-  return /* @__PURE__ */ jsx(InfoIcon, { icon: InfoOutlineIcon, tone: "primary", children: /* @__PURE__ */ jsxs(Stack, { padding: 3, space: 4, style: { maxWidth: 250 }, children: [
+  return /* @__PURE__ */ jsx(InfoIcon, { icon: InfoOutlineIcon, tone: "primary", children: /* @__PURE__ */ jsxs(Stack$1, { padding: 3, space: 4, style: { maxWidth: 250 }, children: [
     /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { size: 1, children: "Bulk publishing uses the Scheduling API." }) }),
     /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { size: 1, children: "Customized Document Actions in the Studio will not execute. Webhooks will execute." }) }),
     /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { size: 1, children: "Validation is checked before rendering the button below, but the Scheduling API will not check for \u2013 or enforce \u2013 validation." }) })
@@ -780,12 +4108,12 @@ function BulkPublish(props) {
     !!(invalidIds && (invalidIds == null ? void 0 : invalidIds.length) > 0) || // No documents are drafts
     !draftIds.length
   );
-  return (translations == null ? void 0 : translations.length) > 0 ? /* @__PURE__ */ jsx(Card, { padding: 4, border: !0, radius: 2, children: /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+  return (translations == null ? void 0 : translations.length) > 0 ? /* @__PURE__ */ jsx(Card, { padding: 4, border: !0, radius: 2, children: /* @__PURE__ */ jsxs(Stack$1, { space: 3, children: [
     /* @__PURE__ */ jsxs(Inline, { space: 3, children: [
       /* @__PURE__ */ jsx(Text, { weight: "bold", size: 1, children: "Bulk publishing" }),
       /* @__PURE__ */ jsx(Info, {})
     ] }),
-    /* @__PURE__ */ jsx(Stack, { children: /* @__PURE__ */ jsx(
+    /* @__PURE__ */ jsx(Stack$1, { children: /* @__PURE__ */ jsx(
       Button,
       {
         onClick: onOpen,
@@ -802,8 +4130,8 @@ function BulkPublish(props) {
         onClose,
         zOffset: 1e3,
         width: 3,
-        children: /* @__PURE__ */ jsxs(Stack, { space: 4, padding: 4, children: [
-          draftIds.length > 0 ? /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+        children: /* @__PURE__ */ jsxs(Stack$1, { space: 4, padding: 4, children: [
+          draftIds.length > 0 ? /* @__PURE__ */ jsxs(Stack$1, { space: 2, children: [
             /* @__PURE__ */ jsxs(Text, { size: 1, children: [
               "There",
               " ",
@@ -816,7 +4144,7 @@ function BulkPublish(props) {
               "validation issues that must addressed first"
             ] }) : /* @__PURE__ */ jsx(TextWithTone, { tone: "positive", size: 1, children: "All drafts are valid and can be bulk published" })
           ] }) : null,
-          /* @__PURE__ */ jsx(Stack, { space: 1, children: translations.filter((translation) => {
+          /* @__PURE__ */ jsx(Stack$1, { space: 1, children: translations.filter((translation) => {
             var _a;
             return (_a = translation == null ? void 0 : translation.value) == null ? void 0 : _a._ref;
           }).map((translation) => /* @__PURE__ */ jsx(
@@ -924,10 +4252,17 @@ var metadata = (schemaTypes, metadataFields) => defineType({
       };
     }
   }
-});
+}), __defProp2 = Object.defineProperty, __defProps = Object.defineProperties, __getOwnPropDescs = Object.getOwnPropertyDescriptors, __getOwnPropSymbols2 = Object.getOwnPropertySymbols, __hasOwnProp2 = Object.prototype.hasOwnProperty, __propIsEnum2 = Object.prototype.propertyIsEnumerable, __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp2.call(b, prop) && __defNormalProp2(a, prop, b[prop]);
+  if (__getOwnPropSymbols2)
+    for (var prop of __getOwnPropSymbols2(b))
+      __propIsEnum2.call(b, prop) && __defNormalProp2(a, prop, b[prop]);
+  return a;
+}, __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 const documentInternationalization = definePlugin(
-  (config) => {
-    const pluginConfig = { ...DEFAULT_CONFIG, ...config }, {
+  (config2) => {
+    const pluginConfig = __spreadValues2(__spreadValues2({}, DEFAULT_CONFIG), config2), {
       supportedLanguages,
       schemaTypes,
       languageField,
@@ -942,9 +4277,12 @@ const documentInternationalization = definePlugin(
       name: "@sanity/document-internationalization",
       studio: {
         components: {
-          layout: (props) => DocumentInternationalizationProvider({ ...props, pluginConfig })
+          layout: (props) => DocumentInternationalizationProvider(__spreadProps(__spreadValues2({}, props), { pluginConfig }))
         }
       },
+      i18n: {
+        bundles: [documentInternationalizationUsEnglishLocaleBundle]
+      },
       // Adds:
       // - A bulk-publishing UI component to the form
       // - Will only work for projects on a compatible plan
@@ -956,7 +4294,7 @@ const documentInternationalization = definePlugin(
               const metadataId = (_a = props == null ? void 0 : props.value) == null ? void 0 : _a._id, translations = (_c = (_b = props == null ? void 0 : props.value) == null ? void 0 : _b.translations) != null ? _c : [], weakAndTypedTranslations = translations.filter(
                 ({ value }) => (value == null ? void 0 : value._weak) && value._strengthenOnPublish
               );
-              return /* @__PURE__ */ jsxs(Stack, { space: 5, children: [
+              return /* @__PURE__ */ jsxs(Stack$1, { space: 5, children: [
                 bulkPublish ? /* @__PURE__ */ jsx(BulkPublish, { translations }) : null,
                 weakAndTypedTranslations.length > 0 ? /* @__PURE__ */ jsx(
                   OptimisticallyStrengthen,
@@ -981,7 +4319,7 @@ const documentInternationalization = definePlugin(
           const { schemaType, documentId } = ctx;
           return schemaTypes.includes(schemaType) && documentId ? [
             ...prev,
-            (props) => DocumentInternationalizationMenu({ ...props, documentId })
+            (props) => DocumentInternationalizationMenu(__spreadProps(__spreadValues2({}, props), { documentId }))
           ] : prev;
         },
         badges: (prev, { schemaType }) => schemaTypes.includes(schemaType) ? [(props) => LanguageBadge(props), ...prev] : prev,
@@ -1057,14 +4395,14 @@ const documentInternationalization = definePlugin(
                 ),
                 options: {
                   // @ts-expect-error - Update type once it knows the values of this filter
-                  filter: ({ parent, document }) => {
+                  filter: ({ parent, document: document2 }) => {
                     if (!parent)
                       return null;
                     const language = (Array.isArray(parent) ? parent : [parent]).find((p) => p._key);
-                    return language != null && language._key ? document.schemaTypes ? {
+                    return language != null && language._key ? document2.schemaTypes ? {
                       filter: `_type in $schemaTypes && ${languageField} == $language`,
                       params: {
-                        schemaTypes: document.schemaTypes,
+                        schemaTypes: document2.schemaTypes,
                         language: language._key
                       }
                     } : {
@@ -1085,6 +4423,7 @@ const documentInternationalization = definePlugin(
 export {
   DeleteTranslationAction,
   DocumentInternationalizationMenu,
+  DuplicateWithTranslationsAction,
   documentInternationalization,
   useDocumentInternationalizationContext
 };