@sanity/assist 1.2.14 → 1.2.15-lang.2

package/dist/index.js

@@ -41,6 +41,8 @@ const instructionTaskTypeName = "sanity.assist.instructionTask";
 const fieldPresenceTypeName = "sanity.assist.instructionTask.presence";
 const assistSerializedTypeName = "sanity.assist.serialized.type";
 const assistSerializedFieldTypeName = "sanity.assist.serialized.field";
+const outputFieldTypeName = "sanity.assist.output.field";
+const outputTypeTypeName = "sanity.assist.output.type";
 const fieldPathParam = "pathKey";
 const instructionParam = "instruction";
 const documentRootKey = "<document>";
@@ -175,7 +177,8 @@ function isDisabled(type, allowReadonlyHidden) {
   return !isSchemaAssistEnabled(type) || isUnsupportedType(type) || !allowReadonlyHidden && readonlyHidden;
 }
 function isUnsupportedType(type) {
-  return type.jsonType === "number" || type.name === "sanity.imageCrop" || type.name === "sanity.imageHotspot" || isType(type, "reference") || isType(type, "crossDatasetReference") || isType(type, "slug") || isType(type, "url") || isType(type, "date") || isType(type, "datetime") || isType(type, "file");
+  var _a, _b;
+  return type.jsonType === "number" || type.name === "sanity.imageCrop" || type.name === "sanity.imageHotspot" || isType(type, "reference") && !((_b = (_a = type == null ? void 0 : type.options) == null ? void 0 : _a.aiWritingAssistance) == null ? void 0 : _b.embeddingsIndex) || isType(type, "crossDatasetReference") || isType(type, "slug") || isType(type, "url") || isType(type, "date") || isType(type, "datetime") || isType(type, "file");
 }
 const inlineTypes = ["document", "object", "image", "file"];
 function serializeSchema(schema, options) {
@@ -217,13 +220,14 @@ function getSchemaStub(schemaType, schema, options) {
   return removeUndef(baseSchema);
 }
 function getBaseFields(schema, type, typeName, options) {
-  var _a, _b, _c;
-  const imagePromptField = (_a = type.options) == null ? void 0 : _a.imagePromptField;
+  var _a, _b, _c, _d, _e;
+  const schemaOptions = removeUndef({
+    imagePromptField: (_a = type.options) == null ? void 0 : _a.imagePromptField,
+    embeddingsIndex: (_c = (_b = type.options) == null ? void 0 : _b.aiWritingAssistance) == null ? void 0 : _c.embeddingsIndex
+  });
   return removeUndef({
-    options: imagePromptField ? {
-      imagePromptField
-    } : void 0,
-    values: Array.isArray((_b = type == null ? void 0 : type.options) == null ? void 0 : _b.list) ? (_c = type == null ? void 0 : type.options) == null ? void 0 : _c.list.map(v => {
+    options: Object.keys(schemaOptions).length ? schemaOptions : void 0,
+    values: Array.isArray((_d = type == null ? void 0 : type.options) == null ? void 0 : _d.list) ? (_e = type == null ? void 0 : type.options) == null ? void 0 : _e.list.map(v => {
       var _a2;
       return typeof v === "string" ? v : (_a2 = v.value) != null ? _a2 : "".concat(v.title);
     }) : void 0,
@@ -680,7 +684,6 @@ function useStudioAssistDocument(_ref2) {
   } = _ref2;
   const documentTypeName = schemaType.name;
   const currentUser = sanity.useCurrentUser();
-  const validation = sanity.useValidationStatus(publicId(documentId), schemaType.name).validation;
   const assistDocument = useDocumentState(assistDocumentId(documentTypeName), assistDocumentTypeName);
   const assistTasksStatus = useDocumentState(assistTasksStatusId(documentId != null ? documentId : ""), assistTasksStatusTypeName);
   const client = sanity.useClient({
@@ -705,7 +708,7 @@ function useStudioAssistDocument(_ref2) {
       return {
         ...assistField,
         tasks: tasks.filter(task => task.path === assistField.path),
-        instructions: (_a2 = assistField.instructions) == null ? void 0 : _a2.filter(p => !p.userId || p.userId === (currentUser == null ? void 0 : currentUser.id)).map(instruction => asStudioInstruction(instruction, tasks, validation))
+        instructions: (_a2 = assistField.instructions) == null ? void 0 : _a2.filter(p => !p.userId || p.userId === (currentUser == null ? void 0 : currentUser.id)).map(instruction => asStudioInstruction(instruction, tasks))
       };
     });
     return sanity.typed({
@@ -720,21 +723,12 @@ function useStudioAssistDocument(_ref2) {
       }),
       fields
     });
-  }, [assistDocument, assistTasksStatus, currentUser, validation]);
+  }, [assistDocument, assistTasksStatus, currentUser]);
 }
-function asStudioInstruction(instruction, run, validation) {
-  var _a;
-  const errors = validation.filter(marker => marker.level === "error");
-  const fieldRefs = ((_a = instruction == null ? void 0 : instruction.prompt) != null ? _a : []).flatMap(block => {
-    if (block._type === "block") {
-      return block.children.filter(c => c._type === fieldReferenceTypeName);
-    }
-    return [];
-  });
+function asStudioInstruction(instruction, run) {
   return {
     ...instruction,
-    tasks: run.filter(task => task.instructionKey === instruction._key).filter(task => task.started && /* @__PURE__ */new Date().getTime() - new Date(task.started).getTime() < maxHistoryVisibilityMs),
-    validation: errors.filter(marker => fieldRefs.map(r => r.path).filter(p => !!p).find(path => sanity.pathToString(marker.path) === path))
+    tasks: run.filter(task => task.instructionKey === instruction._key).filter(task => task.started && ( /* @__PURE__ */new Date()).getTime() - new Date(task.started).getTime() < maxHistoryVisibilityMs)
   };
 }
 function useInterval(ms) {
@@ -815,13 +809,13 @@ function InstructionTaskHistoryButton(props) {
     const statusDocId = assistTasksStatusId(documentId);
     const basePath = "".concat(sanity.typed("tasks"), '[_key=="').concat(taskKey, '"]');
     client.patch(statusDocId).set({
-      ["".concat(basePath, ".").concat(sanity.typed("ended"))]: /* @__PURE__ */new Date().toISOString(),
+      ["".concat(basePath, ".").concat(sanity.typed("ended"))]: ( /* @__PURE__ */new Date()).toISOString(),
       ["".concat(basePath, ".").concat(sanity.typed("reason"))]: sanity.typed("aborted")
     }).commit().catch(console.error);
   }, [client, documentId]);
   const titledTasks = react.useMemo(() => {
     var _a2;
-    const t = (_a2 = tasks == null ? void 0 : tasks.filter(task => task.started && /* @__PURE__ */new Date().getTime() - new Date(task.started).getTime() < maxHistoryVisibilityMs).map(task => {
+    const t = (_a2 = tasks == null ? void 0 : tasks.filter(task => task.started && ( /* @__PURE__ */new Date()).getTime() - new Date(task.started).getTime() < maxHistoryVisibilityMs).map(task => {
       var _a3;
       const instruction = instructions == null ? void 0 : instructions.find(i => i._key === task.instructionKey);
       return {
@@ -888,11 +882,10 @@ const TaskStatusButton = react.forwardRef(function TaskStatusButton2(props, ref)
     mode: "bleed",
     onClick,
     tone: hasErrors ? "critical" : void 0,
-    fontSize: 1,
     disabled,
     ref,
     selected,
-    tooltip: TASK_STATUS_BUTTON_TOOLTIP_PROPS
+    tooltipProps: TASK_STATUS_BUTTON_TOOLTIP_PROPS
   });
 });
 function TaskList(props) {
@@ -979,6 +972,50 @@ function useApiClient(customApiClient) {
   });
   return react.useMemo(() => customApiClient ? customApiClient(client) : client, [client, customApiClient]);
 }
+function useTranslate(apiClient) {
+  const [loading, setLoading] = react.useState(false);
+  const user = sanity.useCurrentUser();
+  const schema = sanity.useSchema();
+  const types = react.useMemo(() => serializeSchema(schema, {
+    leanFormat: true
+  }), [schema]);
+  const toast = ui.useToast();
+  const translate = react.useCallback(_ref4 => {
+    let {
+      documentId,
+      languagePath,
+      fieldLanguageMap
+    } = _ref4;
+    setLoading(true);
+    return apiClient.request({
+      method: "POST",
+      url: "/assist/tasks/translate/".concat(apiClient.config().dataset, "?projectId=").concat(apiClient.config().projectId),
+      body: {
+        documentId,
+        types,
+        languagePath,
+        fieldLanguageMap,
+        userId: user == null ? void 0 : user.id
+      }
+    }).catch(e => {
+      toast.push({
+        status: "error",
+        title: "Translate failed",
+        description: e.message
+      });
+      setLoading(false);
+      throw e;
+    }).finally(() => {
+      setTimeout(() => {
+        setLoading(false);
+      }, 2e3);
+    });
+  }, [setLoading, apiClient, toast, user, types]);
+  return react.useMemo(() => ({
+    translate,
+    loading
+  }), [translate, loading]);
+}
 function useGenerateCaption(apiClient) {
   const [loading, setLoading] = react.useState(false);
   const user = sanity.useCurrentUser();
@@ -987,11 +1024,11 @@ function useGenerateCaption(apiClient) {
     leanFormat: true
   }), [schema]);
   const toast = ui.useToast();
-  const generateCaption = react.useCallback(_ref4 => {
+  const generateCaption = react.useCallback(_ref5 => {
     let {
       path,
       documentId
-    } = _ref4;
+    } = _ref5;
     setLoading(true);
     return apiClient.request({
       method: "POST",
@@ -1210,8 +1247,8 @@ function RunInstructionProvider(props) {
       runInstructionRequest({
         ...request,
         instructionKey: instruction._key,
-        userTexts: Object.entries(inputs).map(_ref5 => {
-          let [key, value] = _ref5;
+        userTexts: Object.entries(inputs).map(_ref6 => {
+          let [key, value] = _ref6;
           return {
             blockKey: key,
             userInput: value
@@ -1224,8 +1261,8 @@ function RunInstructionProvider(props) {
   const open = !!runRequest;
   const runDisabled = react.useMemo(() => {
     var _a2, _b;
-    return ((_b = (_a2 = runRequest == null ? void 0 : runRequest.userInputBlocks) == null ? void 0 : _a2.length) != null ? _b : 0) > Object.entries(inputs).filter(_ref6 => {
-      let [, value] = _ref6;
+    return ((_b = (_a2 = runRequest == null ? void 0 : runRequest.userInputBlocks) == null ? void 0 : _a2.length) != null ? _b : 0) > Object.entries(inputs).filter(_ref7 => {
+      let [, value] = _ref7;
       return !!value;
     }).length;
   }, [runRequest == null ? void 0 : runRequest.userInputBlocks, inputs]);
@@ -1336,29 +1373,37 @@ function getAssistableDocId(documentSchemaType, documentId) {
   return documentSchemaType.liveEdit ? baseId : "drafts.".concat(baseId);
 }
 function useRequestRunInstruction(args) {
-  const {
-    documentOnChange,
-    isDocAssistable: isDocAssistable2
-  } = args;
   const {
     runInstruction,
     instructionLoading
   } = useRunInstruction();
-  const [queuedTask, setQueuedTask] = react.useState(void 0);
-  react.useEffect(() => {
-    if (queuedTask && isDocAssistable2) {
-      runInstruction(queuedTask);
-      setQueuedTask(void 0);
-    }
-  }, [queuedTask, isDocAssistable2, runInstruction]);
+  const requestRunInstruction = useDraftDelayedTask({
+    ...args,
+    task: runInstruction
+  });
   return {
     instructionLoading,
-    requestRunInstruction: react.useCallback(task => {
-      documentOnChange(sanity.PatchEvent.from([sanity.unset(["_force_document_creation"])]));
-      setQueuedTask(task);
-    }, [setQueuedTask, documentOnChange])
+    requestRunInstruction
   };
 }
+function useDraftDelayedTask(args) {
+  const {
+    documentOnChange,
+    isDocAssistable: isDocAssistable2,
+    task
+  } = args;
+  const [queuedArgs, setQueuedArgs] = react.useState(void 0);
+  react.useEffect(() => {
+    if (queuedArgs && isDocAssistable2) {
+      task(queuedArgs);
+      setQueuedArgs(void 0);
+    }
+  }, [queuedArgs, isDocAssistable2, task]);
+  return react.useCallback(taskArgs => {
+    documentOnChange(sanity.PatchEvent.from([sanity.unset(["_force_document_creation"])]));
+    setQueuedArgs(taskArgs);
+  }, [setQueuedArgs, documentOnChange]);
+}
 const SparklesIllustration = styled__default.default(icons.SparklesIcon)({
   fontSize: "3.125em",
   "& path": {
@@ -1609,13 +1654,13 @@ function useSelectedSchema(fieldPath, documentSchema) {
     return currentSchema;
   }, [documentSchema, fieldPath]);
 }
-function FieldsInitializer(_ref7) {
+function FieldsInitializer(_ref8) {
   let {
     pathKey,
     activePath,
     fieldExists,
     onChange
-  } = _ref7;
+  } = _ref8;
   const initialized = react.useRef(false);
   react.useEffect(() => {
     if (initialized.current || fieldExists || activePath || !pathKey) {
@@ -1646,7 +1691,7 @@ function FieldAutocomplete(props) {
     return getFieldRefs(schemaType);
   }, [schemaType, includeDocument]);
   const currentField = react.useMemo(() => fieldRefs.find(f => f.key === fieldPath), [fieldPath, fieldRefs]);
-  const autocompleteOptions = react.useMemo(() => fieldRefs.filter(field => filter ? filter(field) : true).map(field => ({
+  const autocompleteOptions = react.useMemo(() => fieldRefs.filter(field => filter ? filter(field) : true).filter(f => !isType(f.schemaType, "reference")).map(field => ({
     value: field.key,
     field
   })), [fieldRefs, filter]);
@@ -2143,10 +2188,10 @@ const assistInspector = {
     showAsAction: false
   }),
   component: AssistInspectorWrapper,
-  onClose(_ref8) {
+  onClose(_ref9) {
     let {
       params
-    } = _ref8;
+    } = _ref9;
     return {
       params: sanity.typed({
         ...params,
@@ -2174,7 +2219,7 @@ function useAssistPresence(path, showFocusWithin) {
     const activePresence = (_b = (_a = tasks == null ? void 0 : tasks.filter(task => !task.ended)) == null ? void 0 : _a.flatMap(task => {
       var _a2;
       return (_a2 = task.presence) != null ? _a2 : [];
-    })) == null ? void 0 : _b.filter(p => p.started && /* @__PURE__ */new Date().getTime() - new Date(p.started).getTime() < maxHistoryVisibilityMs).filter(presence => {
+    })) == null ? void 0 : _b.filter(p => p.started && ( /* @__PURE__ */new Date()).getTime() - new Date(p.started).getTime() < maxHistoryVisibilityMs).filter(presence => {
       if (!presence.path || !path.length) {
         return false;
       }
@@ -2208,7 +2253,7 @@ function aiPresence(presence, path, title) {
     },
     path,
     sessionId: "not-available",
-    lastActiveAt: (_a = presence == null ? void 0 : presence.started) != null ? _a : /* @__PURE__ */new Date().toISOString()
+    lastActiveAt: (_a = presence == null ? void 0 : presence.started) != null ? _a : ( /* @__PURE__ */new Date()).toISOString()
   };
 }
 var __freeze$3 = Object.freeze;
@@ -2219,11 +2264,11 @@ var __template$3 = (cooked, raw) => __freeze$3(__defProp$3(cooked, "raw", {
 var _a$3, _b$1;
 const fadeIn = styled.keyframes(_a$3 || (_a$3 = __template$3(["\n  0% {\n    opacity: 0;\n    transform: scale(0.75);\n  }\n  40% {\n    opacity: 0;\n    transform: scale(0.75);\n  }\n  100% {\n    opacity: 1;\n    transform: scale(1);\n  }\n"])));
 const FadeInDiv = styled__default.default.div(_b$1 || (_b$1 = __template$3(["\n  animation-name: ", ";\n  animation-timing-function: ease-in-out;\n"])), fadeIn);
-const FadeInContent = react.forwardRef(function FadeInContent2(_ref9, ref) {
+const FadeInContent = react.forwardRef(function FadeInContent2(_ref10, ref) {
   let {
     children,
     durationMs = 250
-  } = _ref9;
+  } = _ref10;
   return /* @__PURE__ */jsxRuntime.jsx(FadeInDiv, {
     ref,
     style: {
@@ -2235,47 +2280,47 @@ const FadeInContent = react.forwardRef(function FadeInContent2(_ref9, ref) {
 const purple = {
   "50": {
     title: "Purple 50",
-    hex: "#f8e9fe"
+    hex: "#f8f5ff"
   },
   "100": {
     title: "Purple 100",
-    hex: "#f2d3fe"
+    hex: "#f1ebff"
   },
   "200": {
     title: "Purple 200",
-    hex: "#e6a7fd"
+    hex: "#ece1fe"
   },
   "300": {
     title: "Purple 300",
-    hex: "#d97bfd"
+    hex: "#ccb1fc"
   },
   "400": {
     title: "Purple 400",
-    hex: "#cd4efc"
+    hex: "#b087f7"
   },
   "500": {
     title: "Purple 500",
-    hex: "#c123fc"
+    hex: "#8f57ef"
   },
   "600": {
     title: "Purple 600",
-    hex: "#9d1fcd"
+    hex: "#721fe5"
   },
   "700": {
     title: "Purple 700",
-    hex: "#7a1b9e"
+    hex: "#4c1a9e"
   },
   "800": {
     title: "Purple 800",
-    hex: "#56186f"
+    hex: "#2f1862"
   },
   "900": {
     title: "Purple 900",
-    hex: "#331440"
+    hex: "#23173f"
   },
   "950": {
     title: "Purple 950",
-    hex: "#211229"
+    hex: "#181128"
   }
 };
 var __freeze$2 = Object.freeze;
@@ -2326,7 +2371,11 @@ function AssistAvatar(props) {
         style: {
           color: "inherit"
         },
-        children: /* @__PURE__ */jsxRuntime.jsx(icons.SparklesIcon, {})
+        children: /* @__PURE__ */jsxRuntime.jsx(icons.SparklesIcon, {
+          style: {
+            color: "inherit"
+          }
+        })
       })
     })]
   });
@@ -2492,15 +2541,16 @@ function AssistField(props) {
     showOnboarding,
     dismissOnboarding
   } = useOnboardingFeature(fieldOnboardingKey);
+  const singlePresence = presence[0];
   const actions = /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
     gap: 2,
     align: "center",
     justify: "space-between",
-    children: [presence.map(pre => /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+    children: [singlePresence && /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
       children: /* @__PURE__ */jsxRuntime.jsx(AiFieldPresence, {
-        presence: pre
-      }, pre.lastActiveAt)
-    }, pre.user.id)), isFirstAssisted && showOnboarding && /* @__PURE__ */jsxRuntime.jsx(AssistOnboardingPopover, {
+        presence: singlePresence
+      })
+    }), isFirstAssisted && showOnboarding && /* @__PURE__ */jsxRuntime.jsx(AssistOnboardingPopover, {
       dismiss: dismissOnboarding
     })]
   });
@@ -2972,7 +3022,6 @@ function AssistConnectorsOverlay(props) {
         zIndex: 150
         // zIndex,
       },
-
       children: connectors.map(connector => /* @__PURE__ */jsxRuntime.jsx(ConnectorPath, {
         from: connector.from,
         options,
@@ -3211,6 +3260,1508 @@ function mapBlock(block, migratedContexts) {
     children: ((_d = textBlock.children) != null ? _d : []).map(child => mapBlock(child, migratedContexts))
   };
 }
+const MAX_DEPTH = 6;
+function getDocumentMembersFlat(doc, schemaType) {
+  if (!sanity.isDocumentSchemaType(schemaType)) {
+    console.error("Schema type is not a document");
+    return [];
+  }
+  return extractPaths(doc, schemaType, [], MAX_DEPTH);
+}
+function extractPaths(doc, schemaType, path, maxDepth) {
+  if (path.length >= maxDepth) {
+    return [];
+  }
+  return schemaType.fields.reduce((acc, field) => {
+    var _a;
+    const fieldPath = [...path, field.name];
+    const fieldSchema = field.type;
+    const thisFieldWithPath = {
+      path: fieldPath,
+      name: field.name,
+      schemaType: fieldSchema
+    };
+    if (fieldSchema.jsonType === "object") {
+      const innerFields = extractPaths(doc, fieldSchema, fieldPath, maxDepth);
+      return [...acc, thisFieldWithPath, ...innerFields];
+    } else if (fieldSchema.jsonType === "array" && fieldSchema.of.length && fieldSchema.of.some(item => "fields" in item)) {
+      const {
+        value: arrayValue
+      } = (_a = mutator.extractWithPath(sanity.pathToString(fieldPath), doc)[0]) != null ? _a : {};
+      let arrayPaths = [];
+      if (arrayValue == null ? void 0 : arrayValue.length) {
+        for (const item of arrayValue) {
+          const arrayItemSchema = fieldSchema.of.find(t => t.name === item._type);
+          if (item._key && arrayItemSchema) {
+            const itemPath = [...fieldPath, {
+              _key: item._key
+            }];
+            const innerFields = extractPaths(doc, arrayItemSchema, itemPath, maxDepth);
+            arrayPaths = [...arrayPaths, {
+              path: itemPath,
+              name: item._key,
+              schemaType: arrayItemSchema
+            }, ...innerFields];
+          }
+        }
+      }
+      return [...acc, thisFieldWithPath, ...arrayPaths];
+    }
+    return [...acc, thisFieldWithPath];
+  }, []);
+}
+const defaultLanguageOutputs = function (member, enclosingType, translateFromLanguageId, translateToLanguageIds) {
+  if (member.schemaType.jsonType === "object" && member.schemaType.name.startsWith("internationalizedArray")) {
+    const pathEnd = member.path.slice(-1);
+    const language = sanity.isKeySegment(pathEnd[0]) ? pathEnd[0]._key : null;
+    return language === translateFromLanguageId ? translateToLanguageIds.map(translateToId => ({
+      id: translateToId,
+      outputPath: [...member.path.slice(0, -1), {
+        _key: translateToId
+      }]
+    })) : void 0;
+  }
+  if (enclosingType.jsonType === "object" && enclosingType.name.startsWith("locale")) {
+    return translateFromLanguageId === member.name ? translateToLanguageIds.map(translateToId => ({
+      id: translateToId,
+      outputPath: [...member.path.slice(0, -1), translateToId]
+    })) : void 0;
+  }
+  return void 0;
+};
+function getTranslationMap(documentSchema, documentMembers, translateFromLanguageId, outputLanguageIds, langFn) {
+  var _a, _b, _c;
+  const translationMaps = [];
+  for (const member of documentMembers) {
+    const parentPath = member.path.slice(0, -1);
+    const enclosingType = (_b = (_a = documentMembers.find(m => sanity.pathToString(m.path) === sanity.pathToString(parentPath))) == null ? void 0 : _a.schemaType) != null ? _b : documentSchema;
+    const translations = (_c = langFn(member, enclosingType, translateFromLanguageId, outputLanguageIds)) == null ? void 0 : _c.filter(translation => translation.id !== translateFromLanguageId);
+    if (translations) {
+      translationMaps.push({
+        inputLanguageId: translateFromLanguageId,
+        inputPath: member.path,
+        outputs: translations
+      });
+    }
+  }
+  return translationMaps;
+}
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+
+var isArray$3 = Array.isArray;
+var isArray_1 = isArray$3;
+
+/** Detect free variable `global` from Node.js. */
+
+var freeGlobal$1 = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+var _freeGlobal = freeGlobal$1;
+var freeGlobal = _freeGlobal;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root$3 = freeGlobal || freeSelf || Function('return this')();
+var _root = root$3;
+var root$2 = _root;
+
+/** Built-in value references. */
+var Symbol$3 = root$2.Symbol;
+var _Symbol = Symbol$3;
+var Symbol$2 = _Symbol;
+
+/** Used for built-in method references. */
+var objectProto$4 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString$1 = objectProto$4.toString;
+
+/** Built-in value references. */
+var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : undefined;
+
+/**
+ * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the raw `toStringTag`.
+ */
+function getRawTag$1(value) {
+  var isOwn = hasOwnProperty$3.call(value, symToStringTag$1),
+    tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = undefined;
+    var unmasked = true;
+  } catch (e) {}
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var _getRawTag = getRawTag$1;
+
+/** Used for built-in method references. */
+
+var objectProto$3 = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto$3.toString;
+
+/**
+ * Converts `value` to a string using `Object.prototype.toString`.
+ *
+ * @private
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ */
+function objectToString$1(value) {
+  return nativeObjectToString.call(value);
+}
+var _objectToString = objectToString$1;
+var Symbol$1 = _Symbol,
+  getRawTag = _getRawTag,
+  objectToString = _objectToString;
+
+/** `Object#toString` result references. */
+var nullTag = '[object Null]',
+  undefinedTag = '[object Undefined]';
+
+/** Built-in value references. */
+var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : undefined;
+
+/**
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag$2(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+var _baseGetTag = baseGetTag$2;
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+
+function isObjectLike$1(value) {
+  return value != null && typeof value == 'object';
+}
+var isObjectLike_1 = isObjectLike$1;
+var baseGetTag$1 = _baseGetTag,
+  isObjectLike = isObjectLike_1;
+
+/** `Object#toString` result references. */
+var symbolTag = '[object Symbol]';
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol$3(value) {
+  return typeof value == 'symbol' || isObjectLike(value) && baseGetTag$1(value) == symbolTag;
+}
+var isSymbol_1 = isSymbol$3;
+var isArray$2 = isArray_1,
+  isSymbol$2 = isSymbol_1;
+
+/** Used to match property names within property paths. */
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
+  reIsPlainProp = /^\w*$/;
+
+/**
+ * Checks if `value` is a property name and not a property path.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ */
+function isKey$1(value, object) {
+  if (isArray$2(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == 'number' || type == 'symbol' || type == 'boolean' || value == null || isSymbol$2(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var _isKey = isKey$1;
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+
+function isObject$2(value) {
+  var type = typeof value;
+  return value != null && (type == 'object' || type == 'function');
+}
+var isObject_1 = isObject$2;
+var baseGetTag = _baseGetTag,
+  isObject$1 = isObject_1;
+
+/** `Object#toString` result references. */
+var asyncTag = '[object AsyncFunction]',
+  funcTag = '[object Function]',
+  genTag = '[object GeneratorFunction]',
+  proxyTag = '[object Proxy]';
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction$1(value) {
+  if (!isObject$1(value)) {
+    return false;
+  }
+  // The use of `Object#toString` avoids issues with the `typeof` operator
+  // in Safari 9 which returns 'object' for typed arrays and other constructors.
+  var tag = baseGetTag(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_1 = isFunction$1;
+var root$1 = _root;
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData$1 = root$1['__core-js_shared__'];
+var _coreJsData = coreJsData$1;
+var coreJsData = _coreJsData;
+
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = function () {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+  return uid ? 'Symbol(src)_1.' + uid : '';
+}();
+
+/**
+ * Checks if `func` has its source masked.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+ */
+function isMasked$1(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var _isMasked = isMasked$1;
+
+/** Used for built-in method references. */
+
+var funcProto$1 = Function.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString$1 = funcProto$1.toString;
+
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to convert.
+ * @returns {string} Returns the source code.
+ */
+function toSource$1(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {}
+    try {
+      return func + '';
+    } catch (e) {}
+  }
+  return '';
+}
+var _toSource = toSource$1;
+var isFunction = isFunction_1,
+  isMasked = _isMasked,
+  isObject = isObject_1,
+  toSource = _toSource;
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+  objectProto$2 = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+
+/** Used to detect if a method is native. */
+var reIsNative = RegExp('^' + funcToString.call(hasOwnProperty$2).replace(reRegExpChar, '\\$&').replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');
+
+/**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ *  else `false`.
+ */
+function baseIsNative$1(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+var _baseIsNative = baseIsNative$1;
+
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+
+function getValue$1(object, key) {
+  return object == null ? undefined : object[key];
+}
+var _getValue = getValue$1;
+var baseIsNative = _baseIsNative,
+  getValue = _getValue;
+
+/**
+ * Gets the native function at `key` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the method to get.
+ * @returns {*} Returns the function if it's native, else `undefined`.
+ */
+function getNative$2(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : undefined;
+}
+var _getNative = getNative$2;
+var getNative$1 = _getNative;
+
+/* Built-in method references that are verified to be native. */
+var nativeCreate$4 = getNative$1(Object, 'create');
+var _nativeCreate = nativeCreate$4;
+var nativeCreate$3 = _nativeCreate;
+
+/**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+function hashClear$1() {
+  this.__data__ = nativeCreate$3 ? nativeCreate$3(null) : {};
+  this.size = 0;
+}
+var _hashClear = hashClear$1;
+
+/**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+
+function hashDelete$1(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _hashDelete = hashDelete$1;
+var nativeCreate$2 = _nativeCreate;
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED$1 = '__lodash_hash_undefined__';
+
+/** Used for built-in method references. */
+var objectProto$1 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+
+/**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function hashGet$1(key) {
+  var data = this.__data__;
+  if (nativeCreate$2) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$1 ? undefined : result;
+  }
+  return hasOwnProperty$1.call(data, key) ? data[key] : undefined;
+}
+var _hashGet = hashGet$1;
+var nativeCreate$1 = _nativeCreate;
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Checks if a hash value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Hash
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function hashHas$1(key) {
+  var data = this.__data__;
+  return nativeCreate$1 ? data[key] !== undefined : hasOwnProperty.call(data, key);
+}
+var _hashHas = hashHas$1;
+var nativeCreate = _nativeCreate;
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/**
+ * Sets the hash `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Hash
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the hash instance.
+ */
+function hashSet$1(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;
+  return this;
+}
+var _hashSet = hashSet$1;
+var hashClear = _hashClear,
+  hashDelete = _hashDelete,
+  hashGet = _hashGet,
+  hashHas = _hashHas,
+  hashSet = _hashSet;
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash$1(entries) {
+  var index = -1,
+    length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `Hash`.
+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;
+
+/**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+
+function listCacheClear$1() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var _listCacheClear = listCacheClear$1;
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+
+function eq$1(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_1 = eq$1;
+var eq = eq_1;
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf$4(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var _assocIndexOf = assocIndexOf$4;
+var assocIndexOf$3 = _assocIndexOf;
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype;
+
+/** Built-in value references. */
+var splice = arrayProto.splice;
+
+/**
+ * Removes `key` and its value from the list cache.
+ *
+ * @private
+ * @name delete
+ * @memberOf ListCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function listCacheDelete$1(key) {
+  var data = this.__data__,
+    index = assocIndexOf$3(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var _listCacheDelete = listCacheDelete$1;
+var assocIndexOf$2 = _assocIndexOf;
+
+/**
+ * Gets the list cache value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf ListCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function listCacheGet$1(key) {
+  var data = this.__data__,
+    index = assocIndexOf$2(data, key);
+  return index < 0 ? undefined : data[index][1];
+}
+var _listCacheGet = listCacheGet$1;
+var assocIndexOf$1 = _assocIndexOf;
+
+/**
+ * Checks if a list cache value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf ListCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function listCacheHas$1(key) {
+  return assocIndexOf$1(this.__data__, key) > -1;
+}
+var _listCacheHas = listCacheHas$1;
+var assocIndexOf = _assocIndexOf;
+
+/**
+ * Sets the list cache `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf ListCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the list cache instance.
+ */
+function listCacheSet$1(key, value) {
+  var data = this.__data__,
+    index = assocIndexOf(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var _listCacheSet = listCacheSet$1;
+var listCacheClear = _listCacheClear,
+  listCacheDelete = _listCacheDelete,
+  listCacheGet = _listCacheGet,
+  listCacheHas = _listCacheHas,
+  listCacheSet = _listCacheSet;
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache$1(entries) {
+  var index = -1,
+    length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `ListCache`.
+ListCache$1.prototype.clear = listCacheClear;
+ListCache$1.prototype['delete'] = listCacheDelete;
+ListCache$1.prototype.get = listCacheGet;
+ListCache$1.prototype.has = listCacheHas;
+ListCache$1.prototype.set = listCacheSet;
+var _ListCache = ListCache$1;
+var getNative = _getNative,
+  root = _root;
+
+/* Built-in method references that are verified to be native. */
+var Map$2 = getNative(root, 'Map');
+var _Map = Map$2;
+var Hash = _Hash,
+  ListCache = _ListCache,
+  Map$1 = _Map;
+
+/**
+ * Removes all key-value entries from the map.
+ *
+ * @private
+ * @name clear
+ * @memberOf MapCache
+ */
+function mapCacheClear$1() {
+  this.size = 0;
+  this.__data__ = {
+    'hash': new Hash(),
+    'map': new (Map$1 || ListCache)(),
+    'string': new Hash()
+  };
+}
+var _mapCacheClear = mapCacheClear$1;
+
+/**
+ * Checks if `value` is suitable for use as unique object key.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+ */
+
+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;
+var isKeyable = _isKeyable;
+
+/**
+ * Gets the data for `map`.
+ *
+ * @private
+ * @param {Object} map The map to query.
+ * @param {string} key The reference key.
+ * @returns {*} Returns the map data.
+ */
+function getMapData$4(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;
+}
+var _getMapData = getMapData$4;
+var getMapData$3 = _getMapData;
+
+/**
+ * Removes `key` and its value from the map.
+ *
+ * @private
+ * @name delete
+ * @memberOf MapCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function mapCacheDelete$1(key) {
+  var result = getMapData$3(this, key)['delete'](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _mapCacheDelete = mapCacheDelete$1;
+var getMapData$2 = _getMapData;
+
+/**
+ * Gets the map value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf MapCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function mapCacheGet$1(key) {
+  return getMapData$2(this, key).get(key);
+}
+var _mapCacheGet = mapCacheGet$1;
+var getMapData$1 = _getMapData;
+
+/**
+ * Checks if a map value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf MapCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function mapCacheHas$1(key) {
+  return getMapData$1(this, key).has(key);
+}
+var _mapCacheHas = mapCacheHas$1;
+var getMapData = _getMapData;
+
+/**
+ * Sets the map `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf MapCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the map cache instance.
+ */
+function mapCacheSet$1(key, value) {
+  var data = getMapData(this, key),
+    size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var _mapCacheSet = mapCacheSet$1;
+var mapCacheClear = _mapCacheClear,
+  mapCacheDelete = _mapCacheDelete,
+  mapCacheGet = _mapCacheGet,
+  mapCacheHas = _mapCacheHas,
+  mapCacheSet = _mapCacheSet;
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache$1(entries) {
+  var index = -1,
+    length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `MapCache`.
+MapCache$1.prototype.clear = mapCacheClear;
+MapCache$1.prototype['delete'] = mapCacheDelete;
+MapCache$1.prototype.get = mapCacheGet;
+MapCache$1.prototype.has = mapCacheHas;
+MapCache$1.prototype.set = mapCacheSet;
+var _MapCache = MapCache$1;
+var MapCache = _MapCache;
+
+/** Error message constants. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is used as the map cache key. The `func`
+ * is invoked with the `this` binding of the memoized function.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `_.memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `clear`, `delete`, `get`, `has`, and `set`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @returns {Function} Returns the new memoized function.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ * var other = { 'c': 3, 'd': 4 };
+ *
+ * var values = _.memoize(_.values);
+ * values(object);
+ * // => [1, 2]
+ *
+ * values(other);
+ * // => [3, 4]
+ *
+ * object.a = 2;
+ * values(object);
+ * // => [1, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b']);
+ * values(object);
+ * // => ['a', 'b']
+ *
+ * // Replace `_.memoize.Cache`.
+ * _.memoize.Cache = WeakMap;
+ */
+function memoize$1(func, resolver) {
+  if (typeof func != 'function' || resolver != null && typeof resolver != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function () {
+    var args = arguments,
+      key = resolver ? resolver.apply(this, args) : args[0],
+      cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize$1.Cache || MapCache)();
+  return memoized;
+}
+
+// Expose `MapCache`.
+memoize$1.Cache = MapCache;
+var memoize_1 = memoize$1;
+var memoize = memoize_1;
+
+/** Used as the maximum memoize cache size. */
+var MAX_MEMOIZE_SIZE = 500;
+
+/**
+ * A specialized version of `_.memoize` which clears the memoized function's
+ * cache when it exceeds `MAX_MEMOIZE_SIZE`.
+ *
+ * @private
+ * @param {Function} func The function to have its output memoized.
+ * @returns {Function} Returns the new memoized function.
+ */
+function memoizeCapped$1(func) {
+  var result = memoize(func, function (key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var _memoizeCapped = memoizeCapped$1;
+var memoizeCapped = _memoizeCapped;
+
+/** Used to match property names within property paths. */
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+
+/** Used to match backslashes in property paths. */
+var reEscapeChar = /\\(\\)?/g;
+
+/**
+ * Converts `string` to a property path array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the property path array.
+ */
+var stringToPath$1 = memoizeCapped(function (string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46 /* . */) {
+    result.push('');
+  }
+  string.replace(rePropName, function (match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, '$1') : number || match);
+  });
+  return result;
+});
+var _stringToPath = stringToPath$1;
+
+/**
+ * A specialized version of `_.map` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+
+function arrayMap$1(array, iteratee) {
+  var index = -1,
+    length = array == null ? 0 : array.length,
+    result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+var _arrayMap = arrayMap$1;
+var Symbol = _Symbol,
+  arrayMap = _arrayMap,
+  isArray$1 = isArray_1,
+  isSymbol$1 = isSymbol_1;
+
+/** Used as references for various `Number` constants. */
+var INFINITY$1 = 1 / 0;
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+  symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+/**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString$1(value) {
+  // Exit early for strings to avoid a performance hit in some environments.
+  if (typeof value == 'string') {
+    return value;
+  }
+  if (isArray$1(value)) {
+    // Recursively convert values (susceptible to call stack limits).
+    return arrayMap(value, baseToString$1) + '';
+  }
+  if (isSymbol$1(value)) {
+    return symbolToString ? symbolToString.call(value) : '';
+  }
+  var result = value + '';
+  return result == '0' && 1 / value == -INFINITY$1 ? '-0' : result;
+}
+var _baseToString = baseToString$1;
+var baseToString = _baseToString;
+
+/**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+function toString$1(value) {
+  return value == null ? '' : baseToString(value);
+}
+var toString_1 = toString$1;
+var isArray = isArray_1,
+  isKey = _isKey,
+  stringToPath = _stringToPath,
+  toString = toString_1;
+
+/**
+ * Casts `value` to a path array if it's not one.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {Array} Returns the cast property path array.
+ */
+function castPath$1(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
+}
+var _castPath = castPath$1;
+var isSymbol = isSymbol_1;
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+function toKey$1(value) {
+  if (typeof value == 'string' || isSymbol(value)) {
+    return value;
+  }
+  var result = value + '';
+  return result == '0' && 1 / value == -INFINITY ? '-0' : result;
+}
+var _toKey = toKey$1;
+var castPath = _castPath,
+  toKey = _toKey;
+
+/**
+ * The base implementation of `_.get` without support for default values.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @returns {*} Returns the resolved value.
+ */
+function baseGet$1(object, path) {
+  path = castPath(path, object);
+  var index = 0,
+    length = path.length;
+  while (object != null && index < length) {
+    object = object[toKey(path[index++])];
+  }
+  return index && index == length ? object : undefined;
+}
+var _baseGet = baseGet$1;
+var baseGet = _baseGet;
+
+/**
+ * Gets the value at `path` of `object`. If the resolved value is
+ * `undefined`, the `defaultValue` is returned in its place.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.get(object, 'a[0].b.c');
+ * // => 3
+ *
+ * _.get(object, ['a', '0', 'b', 'c']);
+ * // => 3
+ *
+ * _.get(object, 'a.b.c', 'default');
+ * // => 'default'
+ */
+function get(object, path, defaultValue) {
+  var result = object == null ? undefined : baseGet(object, path);
+  return result === undefined ? defaultValue : result;
+}
+var get_1 = get;
+var get$1 = /*@__PURE__*/getDefaultExportFromCjs(get_1);
+const getLanguageParams = (select, document) => {
+  if (!select || !document) {
+    return {};
+  }
+  const selection = select || {};
+  const selectedValue = {};
+  for (const [key, path] of Object.entries(selection)) {
+    let value = get$1(document, path);
+    if (Array.isArray(value)) {
+      value = value.filter(item => typeof item === "object" ? (item == null ? void 0 : item._type) !== "reference" || "_ref" in item : true);
+    }
+    selectedValue[key] = value;
+  }
+  return selectedValue;
+};
+const FieldTranslationContext = react.createContext({
+  openFieldTranslation: () => {},
+  translationLoading: false
+  //loadLanguages: () => {},
+});
+function useFieldTranslation() {
+  return react.useContext(FieldTranslationContext);
+}
+function FieldTranslationProvider(props) {
+  var _a, _b;
+  const {
+    config: assistConfig
+  } = useAiAssistanceConfig();
+  const apiClient = useApiClient(assistConfig.__customApiClient);
+  const config = (_a = assistConfig.translate) == null ? void 0 : _a.field;
+  const {
+    translate: runTranslate
+  } = useTranslate(apiClient);
+  const [dialogOpen, setDialogOpen] = react.useState(false);
+  const [document, setDocument] = react.useState();
+  const [documentSchema, setDocumentSchema] = react.useState();
+  const [languages, setLanguages] = react.useState();
+  const [fromLanguage, setFromLanguage] = react.useState(void 0);
+  const [toLanguages, setToLanguages] = react.useState(void 0);
+  const [translationMap, setTranslationMap] = react.useState();
+  const close = react.useCallback(() => {
+    setDialogOpen(false);
+    setLanguages(void 0);
+    setDocument(void 0);
+    setDocument(void 0);
+  }, []);
+  const languageClient = sanity.useClient({
+    apiVersion: (_b = config == null ? void 0 : config.apiVersion) != null ? _b : "2022-11-27"
+  });
+  const documentId = document == null ? void 0 : document._id;
+  const id = react.useId();
+  const selectFromLanguage = react.useCallback((from, languages2, document2, documentSchema2) => {
+    var _a2, _b2;
+    setFromLanguage(from);
+    if (!document2 || !documentSchema2 || !languages2) {
+      setTranslationMap(void 0);
+      return;
+    }
+    const to = languages2.filter(l => l.id !== (from == null ? void 0 : from.id));
+    setToLanguages(to);
+    const fromId = from == null ? void 0 : from.id;
+    const toIds = (_a2 = to == null ? void 0 : to.map(l => l.id)) != null ? _a2 : [];
+    const docMembers = getDocumentMembersFlat(document2, documentSchema2);
+    if (fromId && (toIds == null ? void 0 : toIds.length)) {
+      const transMap = getTranslationMap(documentSchema2, docMembers, fromId, toIds, (_b2 = config == null ? void 0 : config.translationOutputs) != null ? _b2 : defaultLanguageOutputs);
+      setTranslationMap(transMap);
+    } else {
+      setTranslationMap(void 0);
+    }
+  }, [config]);
+  const toggleToLanguage = react.useCallback((toggledLang, toLanguages2, languages2) => {
+    if (!languages2) {
+      return;
+    }
+    const wasSelected = !!(toLanguages2 == null ? void 0 : toLanguages2.find(l => l.id === toggledLang.id));
+    const newToLangs = languages2.filter(anyLang => !!(toLanguages2 == null ? void 0 : toLanguages2.find(selectedLang => toggledLang.id !== selectedLang.id && selectedLang.id === anyLang.id)) || toggledLang.id === anyLang.id && !wasSelected);
+    setToLanguages(newToLangs);
+  }, []);
+  const openFieldTranslation = react.useCallback(async _ref11 => {
+    let {
+      document: document2,
+      documentSchema: documentSchema2
+    } = _ref11;
+    setDialogOpen(true);
+    const languageParams = getLanguageParams(config == null ? void 0 : config.selectLanguageParams, document2);
+    const languages2 = await (typeof (config == null ? void 0 : config.languages) === "function" ? config == null ? void 0 : config.languages(languageClient, languageParams) : Promise.resolve(config == null ? void 0 : config.languages));
+    setLanguages(languages2);
+    setDocument(document2);
+    setDocumentSchema(documentSchema2);
+    const fromLanguage2 = languages2 == null ? void 0 : languages2[0];
+    if (fromLanguage2) {
+      selectFromLanguage(fromLanguage2, languages2, document2, documentSchema2);
+    } else {
+      console.error("No languages available for selected language params", languageParams);
+    }
+  }, [selectFromLanguage, config, languageClient]);
+  const contextValue = react.useMemo(() => {
+    return {
+      openFieldTranslation,
+      translationLoading: false
+    };
+  }, [openFieldTranslation]);
+  const runDisabled = !fromLanguage || !(toLanguages == null ? void 0 : toLanguages.length) || !(translationMap == null ? void 0 : translationMap.length) || !documentId;
+  const onRunTranslation = react.useCallback(() => {
+    if (translationMap && documentId) {
+      runTranslate({
+        documentId,
+        fieldLanguageMap: translationMap.map(map => ({
+          ...map,
+          // eslint-disable-next-line max-nested-callbacks
+          outputs: map.outputs.filter(out => !!(toLanguages == null ? void 0 : toLanguages.find(l => l.id === out.id)))
+        }))
+      });
+    }
+    close();
+  }, [translationMap, documentId, runTranslate, close, toLanguages]);
+  const runButton = /* @__PURE__ */jsxRuntime.jsx(ui.Button, {
+    text: "Translate",
+    tone: "primary",
+    icon: icons.PlayIcon,
+    style: {
+      width: "100%"
+    },
+    disabled: runDisabled,
+    onClick: onRunTranslation
+  });
+  return /* @__PURE__ */jsxRuntime.jsxs(FieldTranslationContext.Provider, {
+    value: contextValue,
+    children: [dialogOpen ? /* @__PURE__ */jsxRuntime.jsx(ui.Dialog, {
+      id,
+      width: 1,
+      open: dialogOpen,
+      onClose: close,
+      header: "Translate fields",
+      footer: /* @__PURE__ */jsxRuntime.jsx(ui.Flex, {
+        justify: "space-between",
+        padding: 2,
+        flex: 1,
+        children: runDisabled ? /* @__PURE__ */jsxRuntime.jsx(ui.Tooltip, {
+          content: /* @__PURE__ */jsxRuntime.jsx(ui.Flex, {
+            padding: 2,
+            children: /* @__PURE__ */jsxRuntime.jsx(ui.Text, {
+              children: "Nothing to translate."
+            })
+          }),
+          placement: "top",
+          children: /* @__PURE__ */jsxRuntime.jsx(ui.Flex, {
+            flex: 1,
+            children: runButton
+          })
+        }) : runButton
+      }),
+      children: languages ? /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+        padding: 4,
+        gap: 5,
+        align: "flex-start",
+        justify: "center",
+        children: [/* @__PURE__ */jsxRuntime.jsxs(ui.Stack, {
+          space: 2,
+          children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+            marginBottom: 2,
+            children: /* @__PURE__ */jsxRuntime.jsx(ui.Text, {
+              weight: "semibold",
+              children: "From"
+            })
+          }), languages == null ? void 0 : languages.map(l => {
+            var _a2;
+            return /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+              gap: 3,
+              align: "center",
+              children: [/* @__PURE__ */jsxRuntime.jsx(ui.Radio, {
+                name: "fromLang",
+                value: l.id,
+                checked: l.id === (fromLanguage == null ? void 0 : fromLanguage.id),
+                onClick: () => selectFromLanguage(l, languages, document, documentSchema)
+              }), /* @__PURE__ */jsxRuntime.jsx(ui.Text, {
+                children: (_a2 = l.title) != null ? _a2 : l.id
+              })]
+            }, l.id);
+          })]
+        }), /* @__PURE__ */jsxRuntime.jsxs(ui.Stack, {
+          space: 2,
+          children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+            marginBottom: 2,
+            children: /* @__PURE__ */jsxRuntime.jsx(ui.Text, {
+              weight: "semibold",
+              children: "To"
+            })
+          }), languages == null ? void 0 : languages.filter(l => l.id !== (fromLanguage == null ? void 0 : fromLanguage.id)).map(l => {
+            var _a2;
+            return /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+              gap: 3,
+              align: "center",
+              children: [/* @__PURE__ */jsxRuntime.jsx(ui.Checkbox, {
+                name: "toLang",
+                value: l.id,
+                checked: !!(toLanguages == null ? void 0 : toLanguages.find(tl => tl.id === l.id)),
+                onClick: () => toggleToLanguage(l, toLanguages, languages),
+                disabled: !(translationMap == null ? void 0 : translationMap.find(tm => tm.outputs.find(o => o.id === l.id)))
+              }), /* @__PURE__ */jsxRuntime.jsx(ui.Text, {
+                children: (_a2 = l.title) != null ? _a2 : l.id
+              })]
+            }, l.id);
+          })]
+        })]
+      }) : /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+        padding: 4,
+        gap: 2,
+        align: "flex-start",
+        justify: "center",
+        children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+          children: /* @__PURE__ */jsxRuntime.jsx(ui.Spinner, {})
+        }), /* @__PURE__ */jsxRuntime.jsx(ui.Text, {
+          children: "Loading languages..."
+        })]
+      })
+    }) : null, props.children]
+  });
+}
 function AssistLayout(props) {
   var _a;
   const [connectors, setConnectors] = react.useState([]);
@@ -3218,14 +4769,16 @@ function AssistLayout(props) {
   return /* @__PURE__ */jsxRuntime.jsxs(AiAssistanceConfigProvider, {
     config: props.config,
     children: [migrate ? /* @__PURE__ */jsxRuntime.jsx(AlphaMigration, {}) : null, /* @__PURE__ */jsxRuntime.jsx(RunInstructionProvider, {
-      children: /* @__PURE__ */jsxRuntime.jsxs(ConnectorsProvider, {
-        onConnectorsChange: setConnectors,
-        children: [props.renderDefault(props), /* @__PURE__ */jsxRuntime.jsx(ui.ThemeProvider, {
-          tone: "default",
-          children: /* @__PURE__ */jsxRuntime.jsx(AssistConnectorsOverlay, {
-            connectors
-          })
-        })]
+      children: /* @__PURE__ */jsxRuntime.jsx(FieldTranslationProvider, {
+        children: /* @__PURE__ */jsxRuntime.jsxs(ConnectorsProvider, {
+          onConnectorsChange: setConnectors,
+          children: [props.renderDefault(props), /* @__PURE__ */jsxRuntime.jsx(ui.ThemeProvider, {
+            tone: "default",
+            children: /* @__PURE__ */jsxRuntime.jsx(AssistConnectorsOverlay, {
+              connectors
+            })
+          })]
+        })
       })
     })]
   });
@@ -3321,6 +4874,7 @@ function AssistFormBlock(props) {
       _key: key
     }));
   }, [onChange, key]);
+  const singlePresence = presence[0];
   return /* @__PURE__ */jsxRuntime.jsx(ErrorWrapper, {
     onChange: localOnChange,
     children: /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
@@ -3329,9 +4883,9 @@ function AssistFormBlock(props) {
       children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
         flex: 1,
         children: props.renderDefault(props)
-      }), presence.map(pre => /* @__PURE__ */jsxRuntime.jsx(AiFieldPresence, {
-        presence: pre
-      }, pre.lastActiveAt))]
+      }), singlePresence && /* @__PURE__ */jsxRuntime.jsx(AiFieldPresence, {
+        presence: singlePresence
+      })]
     })
   });
 }
@@ -3375,16 +4929,24 @@ function InstructionInput(props) {
       ...props
     }), /* @__PURE__ */jsxRuntime.jsx(ShareField, {
       ...props
-    }), /* @__PURE__ */jsxRuntime.jsx(PromptField, {
+    }), /* @__PURE__ */jsxRuntime.jsx(ObjectMember, {
+      fieldName: "prompt",
+      ...props
+    }), /* @__PURE__ */jsxRuntime.jsx(ObjectMember, {
+      fieldName: "output",
       ...props
     })]
   });
 }
-function PromptField(props) {
-  const promptMember = findFieldMember(props.members, "prompt");
-  return promptMember ? /* @__PURE__ */jsxRuntime.jsx(sanity.ObjectInputMember, {
+function ObjectMember(_ref12) {
+  let {
+    fieldName,
+    ...props
+  } = _ref12;
+  const member = findFieldMember(props.members, fieldName);
+  return member ? /* @__PURE__ */jsxRuntime.jsx(sanity.ObjectInputMember, {
     ...props,
-    member: promptMember
+    member
   }) : null;
 }
 const NONE = [];
@@ -3519,8 +5081,8 @@ function IconInput(props) {
     onChange
   } = props;
   const id = react.useId();
-  const items = react.useMemo(() => Object.entries(icons.icons).map(_ref10 => {
-    let [key, icon] = _ref10;
+  const items = react.useMemo(() => Object.entries(icons.icons).map(_ref13 => {
+    let [key, icon] = _ref13;
     return /* @__PURE__ */jsxRuntime.jsx(IconItem, {
       iconKey: key,
       icon,
@@ -3548,12 +5110,12 @@ function IconInput(props) {
     }
   });
 }
-function IconItem(_ref11) {
+function IconItem(_ref14) {
   let {
     icon,
     iconKey: key,
     onChange
-  } = _ref11;
+  } = _ref14;
   const onClick = react.useCallback(() => onChange(sanity.set(key)), [onChange, key]);
   return /* @__PURE__ */jsxRuntime.jsx(ui.MenuItem, {
     icon,
@@ -3564,8 +5126,8 @@ function IconItem(_ref11) {
 }
 function getIcon(iconName) {
   var _a, _b;
-  return (_b = (_a = Object.entries(icons.icons).find(_ref12 => {
-    let [key] = _ref12;
+  return (_b = (_a = Object.entries(icons.icons).find(_ref15 => {
+    let [key] = _ref15;
     return key === iconName;
   })) == null ? void 0 : _a[1]) != null ? _b : icons.icons.sparkles;
 }
@@ -3724,11 +5286,11 @@ const contextDocumentSchema = sanity.defineType({
       title: "title",
       context: "context"
     },
-    prepare(_ref13) {
+    prepare(_ref16) {
       let {
         title,
         context
-      } = _ref13;
+      } = _ref16;
       var _a;
       const text = context == null ? void 0 : context.flatMap(block => block == null ? void 0 : block.children).flatMap(child => {
         var _a2;
@@ -3814,6 +5376,200 @@ function InstructionsArrayField(props) {
     title: " "
   });
 }
+function InstructionOutputField(props) {
+  var _a;
+  const {
+    fieldSchema
+  } = (_a = react.useContext(SelectedFieldContext)) != null ? _a : {};
+  if (!fieldSchema || !(sanity.isObjectSchemaType(fieldSchema) || sanity.isArrayOfObjectsSchemaType(fieldSchema))) {
+    return null;
+  }
+  return /* @__PURE__ */jsxRuntime.jsx(EnabledOutputField, {
+    ...props,
+    fieldSchema,
+    children: props.children
+  });
+}
+function EnabledOutputField(_ref17) {
+  let {
+    fieldSchema,
+    ...props
+  } = _ref17;
+  var _a;
+  const [open, setOpen] = react.useState(!!((_a = props.value) == null ? void 0 : _a.length));
+  const onExpand = react.useCallback(() => setOpen(true), []);
+  const onCollapse = react.useCallback(() => setOpen(false), []);
+  return props.renderDefault({
+    ...props,
+    collapsible: true,
+    onExpand,
+    onCollapse,
+    collapsed: !open,
+    level: 1,
+    title: sanity.isObjectSchemaType(fieldSchema) ? "Allowed fields" : "Allowed types"
+  });
+}
+function InstructionOutputInput(props) {
+  var _a;
+  const {
+    fieldSchema
+  } = (_a = react.useContext(SelectedFieldContext)) != null ? _a : {};
+  if (!fieldSchema) {
+    return null;
+  }
+  if (sanity.isObjectSchemaType(fieldSchema)) {
+    return /* @__PURE__ */jsxRuntime.jsx(ObjectOutputInput, {
+      ...props,
+      fieldSchema
+    });
+  }
+  if (sanity.isArrayOfObjectsSchemaType(fieldSchema)) {
+    return /* @__PURE__ */jsxRuntime.jsx(ArrayOutputInput, {
+      ...props,
+      fieldSchema
+    });
+  }
+  return null;
+}
+function useEmptySelectAllValue(value, allowedValues, onChange) {
+  react.useEffect(() => {
+    var _a, _b;
+    const validValues = value == null ? void 0 : value.filter(v => allowedValues.find(f => f.name === (v._type === outputFieldTypeName ? v.relativePath : v.type)));
+    const valueLength = (_a = value == null ? void 0 : value.length) != null ? _a : 0;
+    const validLength = (_b = validValues == null ? void 0 : validValues.length) != null ? _b : 0;
+    if (!validLength && valueLength || validLength >= allowedValues.length) {
+      onChange(sanity.PatchEvent.from([sanity.unset()]));
+    }
+  }, [allowedValues, value, onChange]);
+}
+function ObjectOutputInput(_ref18) {
+  let {
+    fieldSchema,
+    ...props
+  } = _ref18;
+  const {
+    value,
+    onChange
+  } = props;
+  const fields = react.useMemo(() => fieldSchema.fields.filter(field => isAssistSupported(field.type)), [fieldSchema.fields]);
+  useEmptySelectAllValue(value, fields, onChange);
+  const onSelectChange = react.useCallback((checked, selectedValue) => {
+    if (checked) {
+      if (value == null ? void 0 : value.length) {
+        onChange(sanity.PatchEvent.from(sanity.unset([{
+          _key: selectedValue
+        }])));
+      } else {
+        const items = fields.filter(f => f.name !== selectedValue).map(field => sanity.typed({
+          _key: field.name,
+          _type: "sanity.assist.output.field",
+          relativePath: field.name
+        }));
+        onChange(sanity.PatchEvent.from([sanity.setIfMissing([]), sanity.insert(items, "after", [-1])]));
+      }
+    } else {
+      const patchValue = {
+        _key: selectedValue,
+        _type: "sanity.assist.output.field",
+        relativePath: selectedValue
+      };
+      onChange(sanity.PatchEvent.from([sanity.setIfMissing([]), sanity.insert([patchValue], "after", [-1])]));
+    }
+  }, [onChange, value, fields]);
+  return /* @__PURE__ */jsxRuntime.jsx(ui.Stack, {
+    space: 2,
+    children: fields.map(field => {
+      var _a;
+      return /* @__PURE__ */jsxRuntime.jsx(ui.Flex, {
+        align: "center",
+        gap: 2,
+        children: /* @__PURE__ */jsxRuntime.jsx(Selectable, {
+          value: field.name,
+          title: (_a = field.type.title) != null ? _a : field.name,
+          arrayValue: value,
+          onChange: onSelectChange
+        })
+      }, field.name);
+    })
+  });
+}
+function ArrayOutputInput(_ref19) {
+  let {
+    fieldSchema,
+    ...props
+  } = _ref19;
+  const {
+    value,
+    onChange
+  } = props;
+  const ofItems = react.useMemo(() => fieldSchema.of.filter(itemType => isAssistSupported(itemType)), [fieldSchema.of]);
+  useEmptySelectAllValue(value, ofItems, onChange);
+  const onSelectChange = react.useCallback((checked, selectedValue) => {
+    if (checked) {
+      if (value == null ? void 0 : value.length) {
+        onChange(sanity.PatchEvent.from(sanity.unset([{
+          _key: selectedValue
+        }])));
+      } else {
+        const items = ofItems.filter(f => f.name !== selectedValue).map(field => sanity.typed({
+          _key: field.name,
+          _type: "sanity.assist.output.type",
+          type: field.name
+        }));
+        onChange(sanity.PatchEvent.from([sanity.setIfMissing([]), sanity.insert(items, "after", [-1])]));
+      }
+    } else {
+      const patchValue = {
+        _key: selectedValue,
+        _type: "sanity.assist.output.type",
+        type: selectedValue
+      };
+      onChange(sanity.PatchEvent.from([sanity.setIfMissing([]), sanity.insert([patchValue], "after", [-1])]));
+    }
+  }, [onChange, value, ofItems]);
+  return /* @__PURE__ */jsxRuntime.jsx(ui.Stack, {
+    space: 2,
+    children: ofItems.map(itemType => {
+      var _a;
+      return /* @__PURE__ */jsxRuntime.jsx(ui.Flex, {
+        children: /* @__PURE__ */jsxRuntime.jsx(Selectable, {
+          value: itemType.name,
+          title: isType(itemType, "block") ? "Text" : (_a = itemType.title) != null ? _a : itemType.name,
+          arrayValue: value,
+          onChange: onSelectChange
+        })
+      }, itemType.name);
+    })
+  });
+}
+function Selectable(_ref20) {
+  let {
+    title,
+    arrayValue,
+    value,
+    onChange
+  } = _ref20;
+  const checked = !(arrayValue == null ? void 0 : arrayValue.length) || !!(arrayValue == null ? void 0 : arrayValue.find(v => v._key === value));
+  const handleChange = react.useCallback(() => onChange(checked, value), [onChange, checked, value]);
+  return /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+    gap: 2,
+    align: "flex-start",
+    children: [/* @__PURE__ */jsxRuntime.jsx(ui.Checkbox, {
+      checked,
+      onChange: handleChange
+    }), /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
+      marginTop: 1,
+      onClick: () => handleChange,
+      children: /* @__PURE__ */jsxRuntime.jsx(ui.Text, {
+        style: {
+          cursor: "default"
+        },
+        size: 1,
+        children: title
+      })
+    })]
+  });
+}
 const fieldReference = sanity.defineType({
   type: "object",
   name: fieldReferenceTypeName,
@@ -3857,10 +5613,10 @@ const fieldReference = sanity.defineType({
     select: {
       path: "path"
     },
-    prepare(_ref14) {
+    prepare(_ref21) {
       let {
         path
-      } = _ref14;
+      } = _ref21;
       return {
         title: path,
         path,
@@ -3987,7 +5743,6 @@ const prompt = sanity.defineType({
     type: userInput.name,
   }),*/]
 });
-
 const instruction = sanity.defineType({
   type: "object",
   name: instructionTypeName,
@@ -4006,12 +5761,12 @@ const instruction = sanity.defineType({
       title: "title",
       userId: "userId"
     },
-    prepare: _ref15 => {
+    prepare: _ref22 => {
       let {
         icon,
         title,
         userId
-      } = _ref15;
+      } = _ref22;
       return {
         title,
         icon: icon ? icons.icons[icon] : icons.SparklesIcon,
@@ -4116,6 +5871,33 @@ const instruction = sanity.defineType({
       var _a, _b;
       return (_b = (_a = context.currentUser) == null ? void 0 : _a.id) != null ? _b : "";
     }
+  }), sanity.defineField({
+    type: "array",
+    name: "output",
+    title: "Output filter",
+    components: {
+      input: InstructionOutputInput,
+      field: InstructionOutputField
+    },
+    of: [sanity.defineArrayMember({
+      type: "object",
+      name: outputFieldTypeName,
+      title: "Output field",
+      fields: [{
+        type: "string",
+        name: "path",
+        title: "Path"
+      }]
+    }), sanity.defineArrayMember({
+      type: "object",
+      name: outputTypeTypeName,
+      title: "Output type",
+      fields: [{
+        type: "string",
+        name: "type",
+        title: "Type"
+      }]
+    })]
   })]
 });
 const fieldInstructions = sanity.defineType({
@@ -4378,7 +6160,7 @@ function ImageContextProvider(props) {
     children: props.renderDefault(props)
   });
 }
-function node$1(node2) {
+function node$2(node2) {
   return node2;
 }
 const generateCaptionsActions = {
@@ -4399,7 +6181,7 @@ const generateCaptionsActions = {
         documentId
       } = useAssistDocumentContext();
       return react.useMemo(() => {
-        return node$1({
+        return node$2({
           type: "action",
           icon: loading ? () => /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
             style: {
@@ -4430,6 +6212,109 @@ const generateCaptionsActions = {
     return void 0;
   }
 };
+function node$1(node2) {
+  return node2;
+}
+const translateActions = {
+  name: "sanity-assist-translate",
+  useAction(props) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const {
+      config
+    } = useAiAssistanceConfig();
+    const apiClient = useApiClient(config == null ? void 0 : config.__customApiClient);
+    const isDocumentLevel = props.path.length === 0;
+    const {
+      schemaType,
+      documentId,
+      documentIsAssistable
+    } = props;
+    const fieldTransEnabled = (_c = (_b = (_a = config.translate) == null ? void 0 : _a.field) == null ? void 0 : _b.documentTypes) == null ? void 0 : _c.includes(schemaType.name);
+    const docTransTypes = (_e = (_d = config.translate) == null ? void 0 : _d.document) == null ? void 0 : _e.documentTypes;
+    const documentTranslationEnabled = isDocumentLevel && (!docTransTypes && isAssistSupported(schemaType) || (docTransTypes == null ? void 0 : docTransTypes.includes(schemaType.name)));
+    if (documentTranslationEnabled || fieldTransEnabled) {
+      const {
+        value: documentValue,
+        onChange: documentOnChange
+      } = desk.useDocumentPane();
+      const docRef = react.useRef(documentValue);
+      const translationApi = useTranslate(apiClient);
+      const translate = useDraftDelayedTask({
+        documentOnChange,
+        isDocAssistable: documentIsAssistable != null ? documentIsAssistable : false,
+        task: translationApi.translate
+      });
+      docRef.current = documentValue;
+      const languagePath = (_g = (_f = config.translate) == null ? void 0 : _f.document) == null ? void 0 : _g.languageField;
+      const translateDocumentAction = react.useMemo(() => languagePath && documentTranslationEnabled ? node$1({
+        type: "action",
+        icon: translationApi.loading ? () => /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+          style: {
+            height: 17
+          },
+          children: /* @__PURE__ */jsxRuntime.jsx(ui.Spinner, {
+            style: {
+              transform: "translateY(6px)"
+            }
+          })
+        }) : icons.TranslateIcon,
+        title: "Translate document",
+        onAction: () => {
+          if (translationApi.loading || !languagePath || !documentId) {
+            return;
+          }
+          translate({
+            languagePath,
+            documentId: documentId != null ? documentId : ""
+          });
+        },
+        renderAsButton: true,
+        disabled: translationApi.loading
+      }) : void 0, [languagePath, translate, documentId, translationApi.loading, documentTranslationEnabled]);
+      const fieldTranslate = useFieldTranslation();
+      const openFieldTranslation = useDraftDelayedTask({
+        documentOnChange,
+        isDocAssistable: documentIsAssistable != null ? documentIsAssistable : false,
+        task: fieldTranslate.openFieldTranslation
+      });
+      const translateFieldsAction = react.useMemo(() => fieldTransEnabled ? node$1({
+        type: "action",
+        icon: fieldTranslate.translationLoading ? () => /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+          style: {
+            height: 17
+          },
+          children: /* @__PURE__ */jsxRuntime.jsx(ui.Spinner, {
+            style: {
+              transform: "translateY(6px)"
+            }
+          })
+        }) : icons.TranslateIcon,
+        title: "Translate fields",
+        onAction: () => {
+          if (fieldTranslate.translationLoading || !documentId) {
+            return;
+          }
+          openFieldTranslation({
+            document: docRef.current,
+            documentSchema: schemaType
+          });
+        },
+        renderAsButton: true,
+        disabled: fieldTranslate.translationLoading
+      }) : void 0, [openFieldTranslation, schemaType, documentId, fieldTranslate.translationLoading, fieldTransEnabled]);
+      return react.useMemo(() => {
+        return node$1({
+          type: "group",
+          icon: () => null,
+          title: "Translate",
+          children: [translateDocumentAction, translateFieldsAction].filter(c => !!c),
+          expanded: true
+        });
+      }, [translateDocumentAction, translateFieldsAction]);
+    }
+    return void 0;
+  }
+};
 function node(node2) {
   return node2;
 }
@@ -4450,7 +6335,8 @@ const assistFieldActions = {
       documentOnChange,
       documentSchemaType,
       documentId,
-      selectedPath
+      selectedPath,
+      assistableDocumentId
     } =
     // document field actions do not have access to the document context
     // conditional hook _should_ be safe here since the logical path will be stable
@@ -4485,6 +6371,11 @@ const assistFieldActions = {
     const isPathSelected = pathKey === selectedPath;
     const isSelected = isInspectorOpen && isPathSelected;
     const imageCaptionAction = generateCaptionsActions.useAction(props);
+    const translateAction = translateActions.useAction(sanity.typed({
+      ...props,
+      documentId: assistableDocumentId,
+      documentIsAssistable
+    }));
     const manageInstructions = react.useCallback(() => isSelected ? closeInspector(aiInspectorId) : openInspector(aiInspectorId, {
       [fieldPathParam]: pathKey,
       [instructionParam]: void 0
@@ -4511,7 +6402,7 @@ const assistFieldActions = {
     }, [fieldAssist == null ? void 0 : fieldAssist.instructions]);
     const instructions = react.useMemo(() => [...privateInstructions, ...sharedInstructions], [privateInstructions, sharedInstructions]);
     const runInstructionsGroup = react.useMemo(() => {
-      return (instructions == null ? void 0 : instructions.length) || imageCaptionAction ? node({
+      return (instructions == null ? void 0 : instructions.length) || imageCaptionAction || translateAction ? node({
         type: "group",
         icon: () => null,
         title: "Run instructions",
@@ -4522,10 +6413,10 @@ const assistFieldActions = {
           hidden: isHidden,
           documentIsNew: !!documentIsNew,
           assistSupported
-        }))), imageCaptionAction].filter(Boolean),
+        }))), imageCaptionAction].filter(a => !!a),
         expanded: true
       }) : void 0;
-    }, [instructions, currentUser == null ? void 0 : currentUser.id, onInstructionAction, isHidden, documentIsNew, assistSupported, imageCaptionAction]);
+    }, [instructions, currentUser == null ? void 0 : currentUser.id, onInstructionAction, isHidden, documentIsNew, assistSupported, imageCaptionAction, translateAction]);
     const instructionsLength = (instructions == null ? void 0 : instructions.length) || 0;
     const manageInstructionsItem = react.useMemo(() => node({
       type: "action",
@@ -4538,13 +6429,13 @@ const assistFieldActions = {
       type: "group",
       icon: icons.SparklesIcon,
       title: pluginTitleShort,
-      children: [runInstructionsGroup, assistSupported && manageInstructionsItem].filter(c => !!c),
+      children: [runInstructionsGroup, translateAction, assistSupported && manageInstructionsItem].filter(c => !!c),
       expanded: false,
       renderAsButton: true,
-      hidden: !assistSupported && !imageCaptionAction
+      hidden: !assistSupported && !imageCaptionAction && !translateAction
     }), [
     //documentIsNew,
-    runInstructionsGroup, manageInstructionsItem, assistSupported, imageCaptionAction]);
+    runInstructionsGroup, manageInstructionsItem, assistSupported, imageCaptionAction, translateAction]);
     const emptyAction = react.useMemo(() => node({
       type: "action",
       hidden: !assistSupported,
@@ -4554,7 +6445,7 @@ const assistFieldActions = {
       title: pluginTitleShort,
       selected: isSelected
     }), [assistSupported, manageInstructions, isSelected]);
-    if (instructionsLength === 0 && !imageCaptionAction) {
+    if (instructionsLength === 0 && !imageCaptionAction && !translateAction) {
       return emptyAction;
     }
     return group;
@@ -4667,11 +6558,11 @@ function AssistDocumentInputWrapper(props) {
     documentId
   });
 }
-function AssistDocumentInput(_ref16) {
+function AssistDocumentInput(_ref23) {
   let {
     documentId,
     ...props
-  } = _ref16;
+  } = _ref23;
   useInstructionToaster(documentId, props.schemaType);
   return /* @__PURE__ */jsxRuntime.jsx(FirstAssistedPathProvider, {
     members: props.members,
@@ -4716,11 +6607,11 @@ function AssistDocumentPresence(props) {
     const anyPresence2 = (_b = (_a = assistDocument == null ? void 0 : assistDocument.tasks) == null ? void 0 : _a.filter(run => !run.ended && !run.reason)) == null ? void 0 : _b.flatMap(run => {
       var _a2;
       return (_a2 = run.presence) != null ? _a2 : [];
-    }).find(f => f.started && /* @__PURE__ */new Date().getTime() - new Date(f.started).getTime() < 3e4);
+    }).find(f => f.started && ( /* @__PURE__ */new Date()).getTime() - new Date(f.started).getTime() < 3e4);
     if (anyPresence2) {
       return aiPresence(anyPresence2, []);
     }
-    const anyRun = (_d = (_c = assistDocument == null ? void 0 : assistDocument.tasks) == null ? void 0 : _c.filter(run => !run.ended && !run.reason)) == null ? void 0 : _d.find(f => f.started && /* @__PURE__ */new Date().getTime() - new Date(f.started).getTime() < 3e4);
+    const anyRun = (_d = (_c = assistDocument == null ? void 0 : assistDocument.tasks) == null ? void 0 : _c.filter(run => !run.ended && !run.reason)) == null ? void 0 : _d.find(f => f.started && ( /* @__PURE__ */new Date()).getTime() - new Date(f.started).getTime() < 3e4);
     return anyRun ? aiPresence({
       started: anyRun.started,
       path: documentRootKey,
@@ -4749,6 +6640,9 @@ const assist = sanity.definePlugin(config => {
     schema: {
       types: schemaTypes
     },
+    i18n: {
+      bundles: [{}]
+    },
     document: {
       inspectors: (prev, context) => {
         const docSchema = context.schema.get(context.documentType);
@@ -4757,23 +6651,23 @@ const assist = sanity.definePlugin(config => {
         }
         return prev;
       },
-      unstable_fieldActions: (prev, _ref17) => {
+      unstable_fieldActions: (prev, _ref24) => {
         let {
           documentType,
           schema
-        } = _ref17;
+        } = _ref24;
         const docSchema = schema.get(documentType);
         if (docSchema && isSchemaAssistEnabled(docSchema)) {
           return [...prev, assistFieldActions];
         }
         return prev;
       },
-      unstable_languageFilter: (prev, _ref18) => {
+      unstable_languageFilter: (prev, _ref25) => {
         let {
           documentId,
           schema,
           schemaType
-        } = _ref18;
+        } = _ref25;
         const docSchema = schema.get(schemaType);
         if (docSchema && sanity.isObjectSchemaType(docSchema) && isSchemaAssistEnabled(docSchema)) {
           return [...prev, createAssistDocumentPresence(documentId, docSchema)];