@sanity/assist 1.1.4 → 1.2.0

package/dist/index.esm.js

@@ -1,13 +1,16 @@
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import { useClient, typed, useSchema, useDocumentStore, useDocumentPresence, createPatchChannel, FormBuilder, fromMutationPatches, pathToString, isObjectSchemaType, useEditState, useCurrentUser, useValidationStatus, StatusButton, FormFieldHeaderText, PatchEvent, unset, PresenceOverlay, VirtualizerScrollInstanceProvider, stringToPath, isKeySegment, useColorSchemeValue, isArraySchemaType, useFormCallbacks, set, FormCallbacksProvider, FormInput, setIfMissing, insert, ObjectInputMember, defineType, defineField, defineArrayMember, getPublishedId, definePlugin } from 'sanity';
-import { Card, Stack, Box, Button, Spinner, Flex, Label, focusFirstDescendant, Text, useClickOutside, Popover, useLayer, useGlobalKeyDown, useToast, Dialog, Tooltip, TextArea, Container, Badge, useTheme, rgba, ThemeProvider, ErrorBoundary, Switch, MenuButton, Menu, MenuItem, Breadcrumbs, Autocomplete } from '@sanity/ui';
+import { useClient, typed, useSchema, useDocumentStore, useDocumentPresence, createPatchChannel, FormBuilder, fromMutationPatches, pathToString, isObjectSchemaType, stringToPath, isKeySegment, useEditState, useCurrentUser, useValidationStatus, StatusButton, FormFieldHeaderText, PatchEvent, unset, set, useFormCallbacks, FormCallbacksProvider, FormInput, setIfMissing, insert, PresenceOverlay, VirtualizerScrollInstanceProvider, useColorSchemeValue, isArraySchemaType, ObjectInputMember, defineType, defineField, defineArrayMember, getPublishedId, definePlugin } from 'sanity';
+import { Card, Stack as Stack$1, Box, Button, Spinner, Flex, Label, focusFirstDescendant, Text, useClickOutside, Popover, useLayer, useGlobalKeyDown, useToast, Dialog, Tooltip, TextArea, Container, Autocomplete, Breadcrumbs, Badge, useTheme, rgba, ThemeProvider, ErrorBoundary, Switch, MenuButton, Menu, MenuItem } from '@sanity/ui';
 import { useState, useRef, useEffect, useMemo, useCallback, createContext, useReducer, forwardRef, createElement, useContext, useId } from 'react';
-import { SyncIcon, DocumentIcon, LinkIcon, ImageIcon, BlockContentIcon, OlistIcon, BlockquoteIcon, StringIcon, ErrorOutlineIcon, CheckmarkCircleIcon, CloseCircleIcon, ClockIcon, PlayIcon, SparklesIcon, RetryIcon, ArrowRightIcon, CloseIcon, CheckmarkIcon, ArrowLeftIcon, icons, SearchIcon, TokenIcon, DocumentTextIcon, ThListIcon, CodeIcon, ComposeIcon, LockIcon, ControlsIcon } from '@sanity/icons';
+import { SyncIcon, DocumentIcon, LinkIcon, ImageIcon, BlockContentIcon, OlistIcon, BlockquoteIcon, StringIcon, ErrorOutlineIcon, CheckmarkCircleIcon, CloseCircleIcon, ClockIcon, PlayIcon, SparklesIcon, ArrowLeftIcon, SearchIcon, RetryIcon, ArrowRightIcon, CloseIcon, CheckmarkIcon, icons, TokenIcon, DocumentTextIcon, ThListIcon, CodeIcon, ComposeIcon, LockIcon, ControlsIcon } from '@sanity/icons';
 import { mergeMap, share, take, filter, distinctUntilChanged, catchError, tap } from 'rxjs/operators';
 import isEqual from 'react-fast-compare';
 import { throwError, of, partition, merge, switchMap, delay, defer } from 'rxjs';
 import { exhaustMapToWithTrailing } from 'rxjs-exhaustmap-with-trailing';
 import { useDocumentPane, usePaneRouter, DocumentInspectorHeader, DocumentPaneProvider } from 'sanity/desk';
+import require$$1 from 'tty';
+import require$$1$1 from 'util';
+import require$$0 from 'os';
 import styled, { keyframes } from 'styled-components';
 import { minutesToMilliseconds, isAfter, addSeconds } from 'date-fns';
 import formatDistanceToNow from 'date-fns/formatDistanceToNow';
@@ -305,7 +308,7 @@ function SchemaTypeTool() {
     style: {
       height: "calc(100vh - 81px)"
     },
-    children: /* @__PURE__ */jsxs(Stack, {
+    children: /* @__PURE__ */jsxs(Stack$1, {
       space: 4,
       children: [/* @__PURE__ */jsx(Box, {
         children: /* @__PURE__ */jsx(Button, {
@@ -320,7 +323,7 @@ function SchemaTypeTool() {
         })
       }), /* @__PURE__ */jsxs(Flex, {
         gap: 2,
-        children: [/* @__PURE__ */jsxs(Stack, {
+        children: [/* @__PURE__ */jsxs(Stack$1, {
           space: 2,
           children: [/* @__PURE__ */jsx(Label, {
             children: "Studio schema"
@@ -331,7 +334,7 @@ function SchemaTypeTool() {
               })
             }, type.name))
           })]
-        }), /* @__PURE__ */jsxs(Stack, {
+        }), /* @__PURE__ */jsxs(Stack$1, {
           space: 2,
           children: [/* @__PURE__ */jsx(Label, {
             children: "Stored schema"
@@ -506,7 +509,3486 @@ function prepareRebaseEvent(event) {
 }
 const SelectedFieldContext = createContext(void 0);
 const SelectedFieldContextProvider = SelectedFieldContext.Provider;
-const maxDepth = 4;
+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;
+}
+
+/**
+ * Appends the elements of `values` to `array`.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to append.
+ * @returns {Array} Returns `array`.
+ */
+
+function arrayPush$1(array, values) {
+  var index = -1,
+    length = values.length,
+    offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+var _arrayPush = arrayPush$1;
+
+/** 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$7 = freeGlobal || freeSelf || Function('return this')();
+var _root = root$7;
+var root$6 = _root;
+
+/** Built-in value references. */
+var Symbol$4 = root$6.Symbol;
+var _Symbol = Symbol$4;
+var Symbol$3 = _Symbol;
+
+/** Used for built-in method references. */
+var objectProto$5 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString$1 = objectProto$5.toString;
+
+/** Built-in value references. */
+var symToStringTag$1 = Symbol$3 ? Symbol$3.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$4.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$4 = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto$4.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$2 = _Symbol,
+  getRawTag = _getRawTag,
+  objectToString = _objectToString;
+
+/** `Object#toString` result references. */
+var nullTag = '[object Null]',
+  undefinedTag = '[object Undefined]';
+
+/** Built-in value references. */
+var symToStringTag = Symbol$2 ? Symbol$2.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$3(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+var _baseGetTag = baseGetTag$3;
+
+/**
+ * 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$2(value) {
+  return value != null && typeof value == 'object';
+}
+var isObjectLike_1 = isObjectLike$2;
+var baseGetTag$2 = _baseGetTag,
+  isObjectLike$1 = isObjectLike_1;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]';
+
+/**
+ * The base implementation of `_.isArguments`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ */
+function baseIsArguments$1(value) {
+  return isObjectLike$1(value) && baseGetTag$2(value) == argsTag;
+}
+var _baseIsArguments = baseIsArguments$1;
+var baseIsArguments = _baseIsArguments,
+  isObjectLike = isObjectLike_1;
+
+/** Used for built-in method references. */
+var objectProto$3 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto$3.propertyIsEnumerable;
+
+/**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ *  else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+var isArguments$1 = baseIsArguments(function () {
+  return arguments;
+}()) ? baseIsArguments : function (value) {
+  return isObjectLike(value) && hasOwnProperty$3.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
+};
+var isArguments_1 = isArguments$1;
+
+/**
+ * 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$1 = Array.isArray;
+var isArray_1 = isArray$1;
+var Symbol$1 = _Symbol,
+  isArguments = isArguments_1,
+  isArray = isArray_1;
+
+/** Built-in value references. */
+var spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : undefined;
+
+/**
+ * Checks if `value` is a flattenable `arguments` object or array.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
+ */
+function isFlattenable$1(value) {
+  return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
+}
+var _isFlattenable = isFlattenable$1;
+var arrayPush = _arrayPush,
+  isFlattenable = _isFlattenable;
+
+/**
+ * The base implementation of `_.flatten` with support for restricting flattening.
+ *
+ * @private
+ * @param {Array} array The array to flatten.
+ * @param {number} depth The maximum recursion depth.
+ * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
+ * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
+ * @param {Array} [result=[]] The initial result value.
+ * @returns {Array} Returns the new flattened array.
+ */
+function baseFlatten$1(array, depth, predicate, isStrict, result) {
+  var index = -1,
+    length = array.length;
+  predicate || (predicate = isFlattenable);
+  result || (result = []);
+  while (++index < length) {
+    var value = array[index];
+    if (depth > 0 && predicate(value)) {
+      if (depth > 1) {
+        // Recursively flatten arrays (susceptible to call stack limits).
+        baseFlatten$1(value, depth - 1, predicate, isStrict, result);
+      } else {
+        arrayPush(result, value);
+      }
+    } else if (!isStrict) {
+      result[result.length] = value;
+    }
+  }
+  return result;
+}
+var _baseFlatten = baseFlatten$1;
+var baseFlatten = _baseFlatten;
+
+/**
+ * Flattens `array` a single level deep.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to flatten.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * _.flatten([1, [2, [3, [4]], 5]]);
+ * // => [1, 2, [3, [4]], 5]
+ */
+function flatten(array) {
+  var length = array == null ? 0 : array.length;
+  return length ? baseFlatten(array, 1) : [];
+}
+var flatten_1 = flatten;
+var flatten$1 = /*@__PURE__*/getDefaultExportFromCjs(flatten_1);
+
+/**
+ * Creates an array with all falsey values removed. The values `false`, `null`,
+ * `0`, `""`, `undefined`, and `NaN` are falsey.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to compact.
+ * @returns {Array} Returns the new array of filtered values.
+ * @example
+ *
+ * _.compact([0, 1, false, 2, '', 3]);
+ * // => [1, 2, 3]
+ */
+
+function compact(array) {
+  var index = -1,
+    length = array == null ? 0 : array.length,
+    resIndex = 0,
+    result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (value) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+var compact_1 = compact;
+var compact$1 = /*@__PURE__*/getDefaultExportFromCjs(compact_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$4(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$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;
+var ListCache$3 = _ListCache;
+
+/**
+ * Removes all key-value entries from the stack.
+ *
+ * @private
+ * @name clear
+ * @memberOf Stack
+ */
+function stackClear$1() {
+  this.__data__ = new ListCache$3();
+  this.size = 0;
+}
+var _stackClear = stackClear$1;
+
+/**
+ * Removes `key` and its value from the stack.
+ *
+ * @private
+ * @name delete
+ * @memberOf Stack
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+
+function stackDelete$1(key) {
+  var data = this.__data__,
+    result = data['delete'](key);
+  this.size = data.size;
+  return result;
+}
+var _stackDelete = stackDelete$1;
+
+/**
+ * Gets the stack value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Stack
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+
+function stackGet$1(key) {
+  return this.__data__.get(key);
+}
+var _stackGet = stackGet$1;
+
+/**
+ * Checks if a stack value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Stack
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+
+function stackHas$1(key) {
+  return this.__data__.has(key);
+}
+var _stackHas = stackHas$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$1 = _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$1(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_1 = isFunction$1;
+var root$5 = _root;
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData$1 = root$5['__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$2(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {}
+    try {
+      return func + '';
+    } catch (e) {}
+  }
+  return '';
+}
+var _toSource = toSource$2;
+var isFunction = isFunction_1,
+  isMasked = _isMasked,
+  isObject = isObject_1,
+  toSource$1 = _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$1(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$6(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : undefined;
+}
+var _getNative = getNative$6;
+var getNative$5 = _getNative,
+  root$4 = _root;
+
+/* Built-in method references that are verified to be native. */
+var Map$4 = getNative$5(root$4, 'Map');
+var _Map = Map$4;
+var getNative$4 = _getNative;
+
+/* Built-in method references that are verified to be native. */
+var nativeCreate$4 = getNative$4(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$2 = '__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$2 ? 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$1 = '__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$1 : 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;
+var Hash = _Hash,
+  ListCache$2 = _ListCache,
+  Map$3 = _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$3 || ListCache$2)(),
+    '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$2(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$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;
+var ListCache$1 = _ListCache,
+  Map$2 = _Map,
+  MapCache$1 = _MapCache;
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/**
+ * Sets the stack `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Stack
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the stack cache instance.
+ */
+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) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache$1(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+var _stackSet = stackSet$1;
+var ListCache = _ListCache,
+  stackClear = _stackClear,
+  stackDelete = _stackDelete,
+  stackGet = _stackGet,
+  stackHas = _stackHas,
+  stackSet = _stackSet;
+
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+
+// Add methods to `Stack`.
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+
+/** Used to stand-in for `undefined` hash values. */
+
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/**
+ * Adds `value` to the array cache.
+ *
+ * @private
+ * @name add
+ * @memberOf SetCache
+ * @alias push
+ * @param {*} value The value to cache.
+ * @returns {Object} Returns the cache instance.
+ */
+function setCacheAdd$1(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+var _setCacheAdd = setCacheAdd$1;
+
+/**
+ * Checks if `value` is in the array cache.
+ *
+ * @private
+ * @name has
+ * @memberOf SetCache
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `true` if `value` is found, else `false`.
+ */
+
+function setCacheHas$1(value) {
+  return this.__data__.has(value);
+}
+var _setCacheHas = setCacheHas$1;
+var MapCache = _MapCache,
+  setCacheAdd = _setCacheAdd,
+  setCacheHas = _setCacheHas;
+
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+function SetCache(values) {
+  var index = -1,
+    length = values == null ? 0 : values.length;
+  this.__data__ = new MapCache();
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+
+// Add methods to `SetCache`.
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+var isBuffer = {
+  exports: {}
+};
+
+/**
+ * This method returns `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {boolean} Returns `false`.
+ * @example
+ *
+ * _.times(2, _.stubFalse);
+ * // => [false, false]
+ */
+
+function stubFalse() {
+  return false;
+}
+var stubFalse_1 = stubFalse;
+(function (module, exports) {
+  var root = _root,
+    stubFalse = stubFalse_1;
+
+  /** Detect free variable `exports`. */
+  var freeExports = exports && !exports.nodeType && exports;
+
+  /** Detect free variable `module`. */
+  var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
+
+  /** Detect the popular CommonJS extension `module.exports`. */
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+
+  /** Built-in value references. */
+  var Buffer = moduleExports ? root.Buffer : undefined;
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+
+  /**
+   * Checks if `value` is a buffer.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.3.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+   * @example
+   *
+   * _.isBuffer(new Buffer(2));
+   * // => true
+   *
+   * _.isBuffer(new Uint8Array(2));
+   * // => false
+   */
+  var isBuffer = nativeIsBuffer || stubFalse;
+  module.exports = isBuffer;
+})(isBuffer, isBuffer.exports);
+var _nodeUtil = {
+  exports: {}
+};
+(function (module, exports) {
+  var freeGlobal = _freeGlobal;
+
+  /** Detect free variable `exports`. */
+  var freeExports = exports && !exports.nodeType && exports;
+
+  /** Detect free variable `module`. */
+  var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
+
+  /** Detect the popular CommonJS extension `module.exports`. */
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+
+  /** Detect free variable `process` from Node.js. */
+  var freeProcess = moduleExports && freeGlobal.process;
+
+  /** Used to access faster Node.js helpers. */
+  var nodeUtil = function () {
+    try {
+      // Use `util.types` for Node.js 10+.
+      var types = freeModule && freeModule.require && freeModule.require('util').types;
+      if (types) {
+        return types;
+      }
+
+      // Legacy `process.binding('util')` for Node.js < 10.
+      return freeProcess && freeProcess.binding && freeProcess.binding('util');
+    } catch (e) {}
+  }();
+  module.exports = nodeUtil;
+})(_nodeUtil, _nodeUtil.exports);
+var getNative$3 = _getNative,
+  root$3 = _root;
+
+/* Built-in method references that are verified to be native. */
+var DataView$1 = getNative$3(root$3, 'DataView');
+var _DataView = DataView$1;
+var getNative$2 = _getNative,
+  root$2 = _root;
+
+/* Built-in method references that are verified to be native. */
+var Promise$2 = getNative$2(root$2, 'Promise');
+var _Promise = Promise$2;
+var getNative$1 = _getNative,
+  root$1 = _root;
+
+/* Built-in method references that are verified to be native. */
+var Set$1 = getNative$1(root$1, 'Set');
+var _Set = Set$1;
+var getNative = _getNative,
+  root = _root;
+
+/* Built-in method references that are verified to be native. */
+var WeakMap$1 = getNative(root, 'WeakMap');
+var _WeakMap = WeakMap$1;
+var DataView = _DataView,
+  Map$1 = _Map,
+  Promise$1 = _Promise,
+  Set = _Set,
+  WeakMap = _WeakMap,
+  baseGetTag = _baseGetTag,
+  toSource = _toSource;
+
+/** `Object#toString` result references. */
+var mapTag = '[object Map]',
+  objectTag = '[object Object]',
+  promiseTag = '[object Promise]',
+  setTag = '[object Set]',
+  weakMapTag = '[object WeakMap]';
+var dataViewTag = '[object DataView]';
+
+/** Used to detect maps, sets, and weakmaps. */
+var dataViewCtorString = toSource(DataView),
+  mapCtorString = toSource(Map$1),
+  promiseCtorString = toSource(Promise$1),
+  setCtorString = toSource(Set),
+  weakMapCtorString = toSource(WeakMap);
+
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+var getTag = baseGetTag;
+
+// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map$1 && getTag(new Map$1()) != mapTag || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set && getTag(new Set()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {
+  getTag = function (value) {
+    var result = baseGetTag(value),
+      Ctor = result == objectTag ? value.constructor : undefined,
+      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: {}
+};
+var browser = {
+  exports: {}
+};
+
+/**
+ * Helpers.
+ */
+
+var ms;
+var hasRequiredMs;
+function requireMs() {
+  if (hasRequiredMs) return ms;
+  hasRequiredMs = 1;
+  var s = 1000;
+  var m = s * 60;
+  var h = m * 60;
+  var d = h * 24;
+  var w = d * 7;
+  var y = d * 365.25;
+
+  /**
+   * Parse or format the given `val`.
+   *
+   * Options:
+   *
+   *  - `long` verbose formatting [false]
+   *
+   * @param {String|Number} val
+   * @param {Object} [options]
+   * @throws {Error} throw an error if val is not a non-empty string or a number
+   * @return {String|Number}
+   * @api public
+   */
+
+  ms = function (val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === 'string' && val.length > 0) {
+      return parse(val);
+    } else 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));
+  };
+
+  /**
+   * Parse the given `str` and return milliseconds.
+   *
+   * @param {String} str
+   * @return {Number}
+   * @api private
+   */
+
+  function parse(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
+    }
+    var match = /^(-?(?:\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 (!match) {
+      return;
+    }
+    var n = parseFloat(match[1]);
+    var type = (match[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 undefined;
+    }
+  }
+
+  /**
+   * Short format for `ms`.
+   *
+   * @param {Number} ms
+   * @return {String}
+   * @api private
+   */
+
+  function fmtShort(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return Math.round(ms / d) + 'd';
+    }
+    if (msAbs >= h) {
+      return Math.round(ms / h) + 'h';
+    }
+    if (msAbs >= m) {
+      return Math.round(ms / m) + 'm';
+    }
+    if (msAbs >= s) {
+      return Math.round(ms / s) + 's';
+    }
+    return ms + 'ms';
+  }
+
+  /**
+   * Long format for `ms`.
+   *
+   * @param {Number} ms
+   * @return {String}
+   * @api private
+   */
+
+  function fmtLong(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return plural(ms, msAbs, d, 'day');
+    }
+    if (msAbs >= h) {
+      return plural(ms, msAbs, h, 'hour');
+    }
+    if (msAbs >= m) {
+      return plural(ms, msAbs, m, 'minute');
+    }
+    if (msAbs >= s) {
+      return plural(ms, msAbs, s, 'second');
+    }
+    return ms + ' ms';
+  }
+
+  /**
+   * Pluralization helper.
+   */
+
+  function plural(ms, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+  }
+  return ms;
+}
+var common;
+var hasRequiredCommon;
+function requireCommon() {
+  if (hasRequiredCommon) return common;
+  hasRequiredCommon = 1;
+
+  /**
+   * This is the common logic for both the Node.js and web browser
+   * implementations of `debug()`.
+   */
+  function setup(env) {
+    createDebug.debug = createDebug;
+    createDebug.default = createDebug;
+    createDebug.coerce = coerce;
+    createDebug.disable = disable;
+    createDebug.enable = enable;
+    createDebug.enabled = enabled;
+    createDebug.humanize = requireMs();
+    Object.keys(env).forEach(function (key) {
+      createDebug[key] = env[key];
+    });
+    /**
+    * Active `debug` instances.
+    */
+
+    createDebug.instances = [];
+    /**
+    * The currently active debug mode names, and names to skip.
+    */
+
+    createDebug.names = [];
+    createDebug.skips = [];
+    /**
+    * Map of special "%n" handling functions, for the debug "format" argument.
+    *
+    * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+    */
+
+    createDebug.formatters = {};
+    /**
+    * Selects a color for a debug namespace
+    * @param {String} namespace The namespace string for the for the debug instance to be colored
+    * @return {Number|String} An ANSI color code for the given namespace
+    * @api private
+    */
+
+    function selectColor(namespace) {
+      var hash = 0;
+      for (var i = 0; i < namespace.length; i++) {
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0; // Convert to 32bit integer
+      }
+
+      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+    }
+    createDebug.selectColor = selectColor;
+    /**
+    * Create a debugger with the given `namespace`.
+    *
+    * @param {String} namespace
+    * @return {Function}
+    * @api public
+    */
+
+    function createDebug(namespace) {
+      var prevTime;
+      function debug() {
+        // Disabled?
+        if (!debug.enabled) {
+          return;
+        }
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        var self = debug; // Set `diff` timestamp
+
+        var curr = Number(new Date());
+        var ms = curr - (prevTime || curr);
+        self.diff = ms;
+        self.prev = prevTime;
+        self.curr = curr;
+        prevTime = curr;
+        args[0] = createDebug.coerce(args[0]);
+        if (typeof args[0] !== 'string') {
+          // Anything else let's inspect with %O
+          args.unshift('%O');
+        } // Apply any `formatters` transformations
+
+        var index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) {
+          // If we encounter an escaped % then don't increase the array index
+          if (match === '%%') {
+            return match;
+          }
+          index++;
+          var formatter = createDebug.formatters[format];
+          if (typeof formatter === 'function') {
+            var val = args[index];
+            match = formatter.call(self, val); // Now we need to remove `args[index]` since it's inlined in the `format`
+
+            args.splice(index, 1);
+            index--;
+          }
+          return match;
+        }); // Apply env-specific formatting (colors, etc.)
+
+        createDebug.formatArgs.call(self, args);
+        var logFn = self.log || createDebug.log;
+        logFn.apply(self, args);
+      }
+      debug.namespace = namespace;
+      debug.enabled = createDebug.enabled(namespace);
+      debug.useColors = createDebug.useColors();
+      debug.color = selectColor(namespace);
+      debug.destroy = destroy;
+      debug.extend = extend; // Debug.formatArgs = formatArgs;
+      // debug.rawLog = rawLog;
+      // env-specific initialization logic for debug instances
+
+      if (typeof createDebug.init === 'function') {
+        createDebug.init(debug);
+      }
+      createDebug.instances.push(debug);
+      return debug;
+    }
+    function destroy() {
+      var index = createDebug.instances.indexOf(this);
+      if (index !== -1) {
+        createDebug.instances.splice(index, 1);
+        return true;
+      }
+      return false;
+    }
+    function extend(namespace, delimiter) {
+      return createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+    }
+    /**
+    * Enables a debug mode by namespaces. This can include modes
+    * separated by a colon and wildcards.
+    *
+    * @param {String} namespaces
+    * @api public
+    */
+
+    function enable(namespaces) {
+      createDebug.save(namespaces);
+      createDebug.names = [];
+      createDebug.skips = [];
+      var i;
+      var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+      var len = split.length;
+      for (i = 0; i < len; i++) {
+        if (!split[i]) {
+          // ignore empty strings
+          continue;
+        }
+        namespaces = split[i].replace(/\*/g, '.*?');
+        if (namespaces[0] === '-') {
+          createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+        } else {
+          createDebug.names.push(new RegExp('^' + namespaces + '$'));
+        }
+      }
+      for (i = 0; i < createDebug.instances.length; i++) {
+        var instance = createDebug.instances[i];
+        instance.enabled = createDebug.enabled(instance.namespace);
+      }
+    }
+    /**
+    * Disable debug output.
+    *
+    * @api public
+    */
+
+    function disable() {
+      createDebug.enable('');
+    }
+    /**
+    * Returns true if the given mode name is enabled, false otherwise.
+    *
+    * @param {String} name
+    * @return {Boolean}
+    * @api public
+    */
+
+    function enabled(name) {
+      if (name[name.length - 1] === '*') {
+        return true;
+      }
+      var i;
+      var len;
+      for (i = 0, len = createDebug.skips.length; i < len; i++) {
+        if (createDebug.skips[i].test(name)) {
+          return false;
+        }
+      }
+      for (i = 0, len = createDebug.names.length; i < len; i++) {
+        if (createDebug.names[i].test(name)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    /**
+    * Coerce `val`.
+    *
+    * @param {Mixed} val
+    * @return {Mixed}
+    * @api private
+    */
+
+    function coerce(val) {
+      if (val instanceof Error) {
+        return val.stack || val.message;
+      }
+      return val;
+    }
+    createDebug.enable(createDebug.load());
+    return createDebug;
+  }
+  common = setup;
+  return common;
+}
+var hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser) return browser.exports;
+  hasRequiredBrowser = 1;
+  (function (module, exports) {
+    function _typeof(obj) {
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof = function _typeof(obj) {
+          return typeof obj;
+        };
+      } else {
+        _typeof = function _typeof(obj) {
+          return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+        };
+      }
+      return _typeof(obj);
+    }
+
+    /* eslint-env browser */
+
+    /**
+     * This is the web browser implementation of `debug()`.
+     */
+    exports.log = log;
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    /**
+     * Colors.
+     */
+
+    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'];
+    /**
+     * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+     * and the Firebug extension (any Firefox version) are known
+     * to support "%c" CSS customizations.
+     *
+     * TODO: add a `localStorage` variable to explicitly enable/disable colors
+     */
+    // eslint-disable-next-line complexity
+
+    function useColors() {
+      // NB: In an Electron preload script, document will be defined but not fully
+      // initialized. Since we know we're in Chrome, we'll just detect this case
+      // explicitly
+      if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+        return true;
+      } // Internet Explorer and Edge do not support colors.
+
+      if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      } // Is webkit? http://stackoverflow.com/a/16459606/376773
+      // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+
+      return typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance ||
+      // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== 'undefined' && 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 !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 ||
+      // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    /**
+     * Colorize log arguments if enabled.
+     *
+     * @api public
+     */
+
+    function formatArgs(args) {
+      args[0] = (this.useColors ? '%c' : '') + this.namespace + (this.useColors ? ' %c' : ' ') + args[0] + (this.useColors ? '%c ' : ' ') + '+' + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      var c = 'color: ' + this.color;
+      args.splice(1, 0, c, 'color: inherit'); // The final "%c" is somewhat tricky, because there could be other
+      // arguments passed either before or after the %c, so we need to
+      // figure out the correct index to insert the CSS into
+
+      var index = 0;
+      var lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, function (match) {
+        if (match === '%%') {
+          return;
+        }
+        index++;
+        if (match === '%c') {
+          // We only are interested in the *last* %c
+          // (the user may have provided their own)
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    /**
+     * Invokes `console.log()` when available.
+     * No-op when `console.log` is not a "function".
+     *
+     * @api public
+     */
+
+    function log() {
+      var _console;
+
+      // This hackery is required for IE8/9, where
+      // the `console.log` function doesn't have 'apply'
+      return (typeof console === "undefined" ? "undefined" : _typeof(console)) === 'object' && console.log && (_console = console).log.apply(_console, arguments);
+    }
+    /**
+     * Save `namespaces`.
+     *
+     * @param {String} namespaces
+     * @api private
+     */
+
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem('debug', namespaces);
+        } else {
+          exports.storage.removeItem('debug');
+        }
+      } catch (error) {// Swallow
+        // XXX (@Qix-) should we be logging these?
+      }
+    }
+    /**
+     * Load `namespaces`.
+     *
+     * @return {String} returns the previously persisted debug modes
+     * @api private
+     */
+
+    function load() {
+      var r;
+      try {
+        r = exports.storage.getItem('debug');
+      } catch (error) {} // Swallow
+      // XXX (@Qix-) should we be logging these?
+      // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+
+      if (!r && typeof process !== 'undefined' && 'env' in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    /**
+     * Localstorage attempts to return the localstorage.
+     *
+     * This is necessary because safari throws
+     * when a user disables cookies/localstorage
+     * and you attempt to access it.
+     *
+     * @return {LocalStorage}
+     * @api private
+     */
+
+    function localstorage() {
+      try {
+        // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+        // The Browser also has localStorage in the global context.
+        return localStorage;
+      } catch (error) {// Swallow
+        // XXX (@Qix-) should we be logging these?
+      }
+    }
+    module.exports = requireCommon()(exports);
+    var formatters = module.exports.formatters;
+    /**
+     * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+     */
+
+    formatters.j = function (v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return '[UnexpectedJSONParseError]: ' + error.message;
+      }
+    };
+  })(browser, browser.exports);
+  return browser.exports;
+}
+var node$2 = {
+  exports: {}
+};
+var hasFlag;
+var hasRequiredHasFlag;
+function requireHasFlag() {
+  if (hasRequiredHasFlag) return hasFlag;
+  hasRequiredHasFlag = 1;
+  hasFlag = function (flag) {
+    let argv = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : process.argv;
+    const prefix = flag.startsWith('-') ? '' : flag.length === 1 ? '-' : '--';
+    const position = argv.indexOf(prefix + flag);
+    const terminatorPosition = argv.indexOf('--');
+    return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+  };
+  return hasFlag;
+}
+var supportsColor_1;
+var hasRequiredSupportsColor;
+function requireSupportsColor() {
+  if (hasRequiredSupportsColor) return supportsColor_1;
+  hasRequiredSupportsColor = 1;
+  const os = require$$0;
+  const tty = require$$1;
+  const hasFlag = requireHasFlag();
+  const {
+    env
+  } = process;
+  let forceColor;
+  if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false') || hasFlag('color=never')) {
+    forceColor = 0;
+  } else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) {
+    forceColor = 1;
+  }
+  if ('FORCE_COLOR' in env) {
+    if (env.FORCE_COLOR === 'true') {
+      forceColor = 1;
+    } else if (env.FORCE_COLOR === 'false') {
+      forceColor = 0;
+    } else {
+      forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+    }
+  }
+  function translateLevel(level) {
+    if (level === 0) {
+      return false;
+    }
+    return {
+      level,
+      hasBasic: true,
+      has256: level >= 2,
+      has16m: level >= 3
+    };
+  }
+  function supportsColor(haveStream, streamIsTTY) {
+    if (forceColor === 0) {
+      return 0;
+    }
+    if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) {
+      return 3;
+    }
+    if (hasFlag('color=256')) {
+      return 2;
+    }
+    if (haveStream && !streamIsTTY && forceColor === undefined) {
+      return 0;
+    }
+    const min = forceColor || 0;
+    if (env.TERM === 'dumb') {
+      return min;
+    }
+    if (process.platform === 'win32') {
+      // Windows 10 build 10586 is the first Windows release that supports 256 colors.
+      // Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+      const osRelease = os.release().split('.');
+      if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+        return Number(osRelease[2]) >= 14931 ? 3 : 2;
+      }
+      return 1;
+    }
+    if ('CI' in env) {
+      if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+        return 1;
+      }
+      return min;
+    }
+    if ('TEAMCITY_VERSION' in env) {
+      return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+    }
+    if (env.COLORTERM === 'truecolor') {
+      return 3;
+    }
+    if ('TERM_PROGRAM' in env) {
+      const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+      switch (env.TERM_PROGRAM) {
+        case 'iTerm.app':
+          return version >= 3 ? 3 : 2;
+        case 'Apple_Terminal':
+          return 2;
+        // No default
+      }
+    }
+
+    if (/-256(color)?$/i.test(env.TERM)) {
+      return 2;
+    }
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+      return 1;
+    }
+    if ('COLORTERM' in env) {
+      return 1;
+    }
+    return min;
+  }
+  function getSupportLevel(stream) {
+    const level = supportsColor(stream, stream && stream.isTTY);
+    return translateLevel(level);
+  }
+  supportsColor_1 = {
+    supportsColor: getSupportLevel,
+    stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+    stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+  };
+  return supportsColor_1;
+}
+var hasRequiredNode;
+function requireNode() {
+  if (hasRequiredNode) return node$2.exports;
+  hasRequiredNode = 1;
+  (function (module, exports) {
+    /**
+     * Module dependencies.
+     */
+    var tty = require$$1;
+    var util = require$$1$1;
+    /**
+     * This is the Node.js implementation of `debug()`.
+     */
+
+    exports.init = init;
+    exports.log = log;
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    /**
+     * Colors.
+     */
+
+    exports.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      // Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+      // eslint-disable-next-line import/no-extraneous-dependencies
+      var supportsColor = requireSupportsColor();
+      if (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) {} // Swallow - we only care if `supports-color` is available; it doesn't have to be.
+
+    /**
+     * Build up the default `inspectOpts` object from the environment variables.
+     *
+     *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+     */
+
+    exports.inspectOpts = Object.keys(process.env).filter(function (key) {
+      return /^debug_/i.test(key);
+    }).reduce(function (obj, key) {
+      // Camel-case
+      var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function (_, k) {
+        return k.toUpperCase();
+      }); // Coerce string value into JS value
+
+      var val = process.env[key];
+      if (/^(yes|on|true|enabled)$/i.test(val)) {
+        val = true;
+      } else if (/^(no|off|false|disabled)$/i.test(val)) {
+        val = false;
+      } else if (val === 'null') {
+        val = null;
+      } else {
+        val = Number(val);
+      }
+      obj[prop] = val;
+      return obj;
+    }, {});
+    /**
+     * Is stdout a TTY? Colored output is enabled when `true`.
+     */
+
+    function useColors() {
+      return 'colors' in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+    }
+    /**
+     * Adds ANSI color escape codes if enabled.
+     *
+     * @api public
+     */
+
+    function formatArgs(args) {
+      var name = this.namespace,
+        useColors = this.useColors;
+      if (useColors) {
+        var c = this.color;
+        var colorCode = "\x1B[3" + (c < 8 ? c : '8;5;' + c);
+        var prefix = "  ".concat(colorCode, ";1m").concat(name, " \x1B[0m");
+        args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+        args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + "\x1B[0m");
+      } else {
+        args[0] = getDate() + name + ' ' + args[0];
+      }
+    }
+    function getDate() {
+      if (exports.inspectOpts.hideDate) {
+        return '';
+      }
+      return new Date().toISOString() + ' ';
+    }
+    /**
+     * Invokes `util.format()` with the specified arguments and writes to stderr.
+     */
+
+    function log() {
+      return process.stderr.write(util.format.apply(util, arguments) + '\n');
+    }
+    /**
+     * Save `namespaces`.
+     *
+     * @param {String} namespaces
+     * @api private
+     */
+
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        // If you set a process.env field to null or undefined, it gets cast to the
+        // string 'null' or 'undefined'. Just delete instead.
+        delete process.env.DEBUG;
+      }
+    }
+    /**
+     * Load `namespaces`.
+     *
+     * @return {String} returns the previously persisted debug modes
+     * @api private
+     */
+
+    function load() {
+      return process.env.DEBUG;
+    }
+    /**
+     * Init logic for `debug` instances.
+     *
+     * Create a new `inspectOpts` object in case `useColors` is set
+     * differently for a particular `debug` instance.
+     */
+
+    function init(debug) {
+      debug.inspectOpts = {};
+      var keys = Object.keys(exports.inspectOpts);
+      for (var i = 0; i < keys.length; i++) {
+        debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+      }
+    }
+    module.exports = requireCommon()(exports);
+    var formatters = module.exports.formatters;
+    /**
+     * Map %o to `util.inspect()`, all on a single line.
+     */
+
+    formatters.o = function (v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts).split('\n').map(function (str) {
+        return str.trim();
+      }).join(' ');
+    };
+    /**
+     * Map %O to `util.inspect()`, allowing multiple lines if needed.
+     */
+
+    formatters.O = function (v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts);
+    };
+  })(node$2, node$2.exports);
+  return node$2.exports;
+}
+
+/**
+ * Detect Electron renderer / nwjs process, which is node, but we should
+ * treat as a browser.
+ */
+if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+  src.exports = requireBrowser();
+} else {
+  src.exports = requireNode();
+}
+var srcExports = src.exports;
+var debugIt = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
+var __defProp$h = Object.defineProperty;
+var __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __publicField$h = (obj, key, value) => {
+  __defNormalProp$h(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const digitChar = /[0-9]/;
+const attributeCharMatcher = /^[a-zA-Z0-9_]$/;
+const attributeFirstCharMatcher = /^[a-zA-Z_]$/;
+const symbols = {
+  operator: ["..", ".", ",", ":", "?"],
+  comparator: [">", ">=", "<", "<=", "==", "!="],
+  keyword: ["$", "@"],
+  boolean: ["true", "false"],
+  paren: ["[", "]"]
+};
+const symbolClasses = Object.keys(symbols);
+class Tokenizer {
+  constructor(path) {
+    __publicField$h(this, "source");
+    __publicField$h(this, "i");
+    __publicField$h(this, "length");
+    __publicField$h(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 = [];
+    while (!this.EOF()) {
+      this.chompWhitespace();
+      let token = null;
+      const found = this.tokenizers.some(tokenizer => {
+        token = tokenizer();
+        return Boolean(token);
+      });
+      if (!found || !token) {
+        throw new Error("Invalid tokens in jsonpath '".concat(this.source, "' @ ").concat(this.i));
+      }
+      result.push(token);
+    }
+    return result;
+  }
+  takeWhile(fn) {
+    const start = this.i;
+    let result = "";
+    while (!this.EOF()) {
+      const nextChar = fn(this.source[this.i]);
+      if (nextChar === null) {
+        break;
+      }
+      result += nextChar;
+      this.i++;
+    }
+    if (this.i === start) {
+      return null;
+    }
+    return result;
+  }
+  EOF() {
+    return this.i >= this.length;
+  }
+  peek() {
+    if (this.EOF()) {
+      return null;
+    }
+    return this.source[this.i];
+  }
+  consume(str) {
+    if (this.i + str.length > this.length) {
+      throw new Error("Expected ".concat(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 "'.concat(str, '", but source contained "').concat(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)) {
+      this.i += str.length;
+      return str;
+    }
+    return null;
+  }
+  chompWhitespace() {
+    this.takeWhile(char => {
+      return char === " " ? "" : null;
+    });
+  }
+  tokenizeQuoted() {
+    const quote = this.peek();
+    if (quote === "'" || quote === '"') {
+      this.consume(quote);
+      let escape = false;
+      const inner = this.takeWhile(char => {
+        if (escape) {
+          escape = false;
+          return char;
+        }
+        if (char === "\\") {
+          escape = true;
+          return "";
+        }
+        if (char != quote) {
+          return char;
+        }
+        return null;
+      });
+      this.consume(quote);
+      return {
+        type: "quoted",
+        value: inner,
+        quote: quote === '"' ? "double" : "single"
+      };
+    }
+    return null;
+  }
+  tokenizeIdentifier() {
+    let first = true;
+    const identifier = this.takeWhile(char => {
+      if (first) {
+        first = false;
+        return char.match(attributeFirstCharMatcher) ? char : null;
+      }
+      return char.match(attributeCharMatcher) ? char : null;
+    });
+    if (identifier !== null) {
+      return {
+        type: "identifier",
+        name: identifier
+      };
+    }
+    return null;
+  }
+  tokenizeNumber() {
+    const start = this.i;
+    let dotSeen = false;
+    let digitSeen = false;
+    let negative = false;
+    if (this.peek() === "-") {
+      negative = true;
+      this.consume("-");
+    }
+    const number = this.takeWhile(char => {
+      if (char === "." && !dotSeen && digitSeen) {
+        dotSeen = true;
+        return char;
+      }
+      digitSeen = true;
+      return char.match(digitChar) ? char : null;
+    });
+    if (number !== null) {
+      return {
+        type: "number",
+        value: negative ? -number : +number,
+        raw: negative ? "-".concat(number) : number
+      };
+    }
+    this.i = start;
+    return null;
+  }
+  tokenizeSymbol() {
+    for (const symbolClass of symbolClasses) {
+      const patterns = symbols[symbolClass];
+      const symbol = patterns.find(pattern => this.tryConsume(pattern));
+      if (symbol) {
+        return {
+          type: symbolClass,
+          symbol
+        };
+      }
+    }
+    return null;
+  }
+}
+function tokenize(jsonpath) {
+  return new Tokenizer(jsonpath).tokenize();
+}
+var __defProp$g = Object.defineProperty;
+var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __publicField$g = (obj, key, value) => {
+  __defNormalProp$g(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Parser {
+  constructor(path) {
+    __publicField$g(this, "tokens");
+    __publicField$g(this, "length");
+    __publicField$g(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() {
+    if (this.EOF()) {
+      return null;
+    }
+    return this.tokens[this.i];
+  }
+  consume() {
+    const result = this.peek();
+    this.i += 1;
+    return result;
+  }
+  // Return next token if it matches the pattern
+  probe(pattern) {
+    const token = this.peek();
+    if (!token) {
+      return null;
+    }
+    const record = token;
+    const match = Object.keys(pattern).every(key => {
+      return key in token && pattern[key] === record[key];
+    });
+    return match ? 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"
+    });
+    if (quoted && quoted.type === "quoted") {
+      return {
+        type: "attribute",
+        name: quoted.value || ""
+      };
+    }
+    return null;
+  }
+  parseAlias() {
+    if (this.match({
+      type: "keyword",
+      symbol: "@"
+    }) || this.match({
+      type: "keyword",
+      symbol: "$"
+    })) {
+      return {
+        type: "alias",
+        target: "self"
+      };
+    }
+    return null;
+  }
+  parseNumber() {
+    const token = this.match({
+      type: "number"
+    });
+    if (token && token.type === "number") {
+      return {
+        type: "number",
+        value: token.value
+      };
+    }
+    return null;
+  }
+  parseNumberValue() {
+    const expr = this.parseNumber();
+    if (expr) {
+      return expr.value;
+    }
+    return null;
+  }
+  parseSliceSelector() {
+    const start = this.i;
+    const rangeStart = this.parseNumberValue();
+    const colon1 = this.match({
+      type: "operator",
+      symbol: ":"
+    });
+    if (!colon1) {
+      if (rangeStart === null) {
+        this.i = start;
+        return null;
+      }
+      return {
+        type: "index",
+        value: rangeStart
+      };
+    }
+    const result = {
+      type: "range",
+      start: rangeStart,
+      end: this.parseNumberValue()
+    };
+    const colon2 = this.match({
+      type: "operator",
+      symbol: ":"
+    });
+    if (colon2) {
+      result.step = this.parseNumberValue();
+    }
+    if (result.start === null && result.end === null) {
+      this.i = start;
+      return null;
+    }
+    return 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"
+    });
+    if (literalBoolean && literalBoolean.type === "boolean") {
+      return {
+        type: "boolean",
+        value: literalBoolean.symbol === "true"
+      };
+    }
+    return this.parseNumber();
+  }
+  // TODO: Reorder constraints so that literal value is always on rhs, and variable is always
+  // on lhs.
+  parseFilterExpression() {
+    const start = this.i;
+    const 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") {
+      this.i = start;
+      return null;
+    }
+    const lhs = expr;
+    const rhs = this.parseLiteralValue();
+    if (!rhs) {
+      throw new Error("Operator ".concat(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();
+    while (expr) {
+      terms.push(expr);
+      if (this.match({
+        type: "paren",
+        symbol: "]"
+      })) {
+        break;
+      }
+      if (!this.match({
+        type: "operator",
+        symbol: ","
+      })) {
+        throw new Error("Expected ]");
+      }
+      expr = this.parseFilterExpression() || this.parsePath() || this.parseValueReference();
+      if (!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 = [];
+    const expr = this.parseAttribute() || this.parseUnion() || this.parseRecursive();
+    if (!expr) {
+      return null;
+    }
+    nodes.push(expr);
+    while (!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();
+        if (recursive) {
+          nodes.push(recursive);
+        }
+        break;
+      }
+    }
+    if (nodes.length === 1) {
+      return nodes[0];
+    }
+    return {
+      type: "path",
+      nodes
+    };
+  }
+}
+function parseJsonPath(path) {
+  const parsed = new Parser(path).parse();
+  if (!parsed) {
+    throw new Error('Failed to parse JSON path "'.concat(path, '"'));
+  }
+  return parsed;
+}
+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;
+  if (nodes.length === 0) {
+    return [null, null];
+  }
+  if (nodes.length === 1) {
+    return [nodes[0], null];
+  }
+  return [nodes[0], {
+    type: "path",
+    nodes: nodes.slice(1)
+  }];
+}
+function concatPaths(path1, path2) {
+  if (!path1 && !path2) {
+    return null;
+  }
+  const nodes1 = path1 ? path1.nodes : [];
+  const nodes2 = path2 ? path2.nodes : [];
+  return {
+    type: "path",
+    nodes: nodes1.concat(nodes2)
+  };
+}
+function spreadIfUnionHead(head, tail) {
+  if (head.type !== "union") {
+    return [[head, tail]];
+  }
+  return head.nodes.map(node => {
+    if (node.type === "path") {
+      const [subHead, subTail] = splitIfPath(node);
+      return [subHead, concatPaths(subTail, tail)];
+    }
+    return [node, tail];
+  });
+}
+function toPath(expr) {
+  return toPathInner(expr, false);
+}
+function toPathInner(expr, inUnion) {
+  switch (expr.type) {
+    case "attribute":
+      return expr.name;
+    case "alias":
+      return expr.target === "self" ? "@" : "$";
+    case "number":
+      return "".concat(expr.value);
+    case "range":
+      {
+        const result = [];
+        if (!inUnion) {
+          result.push("[");
+        }
+        if (expr.start) {
+          result.push("".concat(expr.start));
+        }
+        result.push(":");
+        if (expr.end) {
+          result.push("".concat(expr.end));
+        }
+        if (expr.step) {
+          result.push(":".concat(expr.step));
+        }
+        if (!inUnion) {
+          result.push("]");
+        }
+        return result.join("");
+      }
+    case "index":
+      if (inUnion) {
+        return "".concat(expr.value);
+      }
+      return "[".concat(expr.value, "]");
+    case "constraint":
+      {
+        const rhs = expr.rhs ? " ".concat(toPathInner(expr.rhs, false)) : "";
+        const inner = "".concat(toPathInner(expr.lhs, false), " ").concat(expr.operator).concat(rhs);
+        if (inUnion) {
+          return inner;
+        }
+        return "[".concat(inner, "]");
+      }
+    case "string":
+      return JSON.stringify(expr.value);
+    case "path":
+      {
+        const result = [];
+        const nodes = expr.nodes.slice();
+        while (nodes.length > 0) {
+          const node = nodes.shift();
+          if (node) {
+            result.push(toPath(node));
+          }
+          const upcoming = nodes[0];
+          if (upcoming && toPathInner(upcoming, false)[0] !== "[") {
+            result.push(".");
+          }
+        }
+        return result.join("");
+      }
+    case "union":
+      return "[".concat(expr.nodes.map(e => toPathInner(e, true)).join(","), "]");
+    default:
+      throw new Error("Unknown node type ".concat(expr.type));
+    case "recursive":
+      return "..".concat(toPathInner(expr.term, false));
+  }
+}
+var __defProp$f = Object.defineProperty;
+var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __publicField$f = (obj, key, value) => {
+  __defNormalProp$f(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Expression {
+  constructor(expr) {
+    __publicField$f(this, "expr");
+    if (!expr) {
+      throw new Error("Attempted to create Expression from null-value");
+    }
+    if ("expr" in expr) {
+      this.expr = expr.expr;
+    } else {
+      this.expr = expr;
+    }
+    if (!("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 : 0;
+    start = interpretNegativeIndex(start, probe);
+    let end = "end" in this.expr ? this.expr.end || probeLength() : probeLength();
+    end = interpretNegativeIndex(end, probe);
+    const step = "step" in this.expr ? this.expr.step || 1 : 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 false;
+      }
+      if (expr.type === "constraint" && expr.operator === "?") {
+        return true;
+      }
+      const lhs2 = probe.get();
+      const rhs2 = expr.rhs && "value" in expr.rhs ? expr.rhs.value : void 0;
+      return testBinaryOperator(lhs2, expr.operator, rhs2);
+    }
+    if (expr.type !== "constraint") {
+      return false;
+    }
+    const lhs = expr.lhs;
+    if (!lhs) {
+      throw new Error("No LHS of expression");
+    }
+    if (lhs.type !== "attribute") {
+      throw new Error("Constraint target ".concat(lhs.type, " not supported"));
+    }
+    if (probe.containerType() !== "object") {
+      return false;
+    }
+    const lhsValue = probe.getAttribute(lhs.name);
+    if (lhsValue === void 0 || lhsValue === null || lhsValue.containerType() !== "primitive") {
+      return false;
+    }
+    if (this.isExistenceConstraint()) {
+      return true;
+    }
+    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(node) {
+    if (!node) {
+      return this;
+    }
+    return new Expression({
+      type: "path",
+      nodes: node.pathNodes().concat(this.pathNodes())
+    });
+  }
+  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 ".concat(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 = [];
+    const range = this.expandRange(probe);
+    let {
+      start,
+      end
+    } = range;
+    if (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 ".concat(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 "'.concat(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 ".concat(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$e = Object.defineProperty;
+var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __publicField$e = (obj, key, value) => {
+  __defNormalProp$e(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Descender {
+  constructor(head, tail) {
+    __publicField$e(this, "head");
+    __publicField$e(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 = true;
+      while (anyConstraints) {
+        result = flatten$1(result.map(descender => {
+          return descender.iterateConstraints(probe);
+        }));
+        anyConstraints = result.some(descender => {
+          return descender.head && descender.head.isConstraint();
+        });
+      }
+    }
+    return result;
+  }
+  isRecursive() {
+    return Boolean(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()) {
+      if (head.testConstraint(probe)) {
+        result.push(...this.descend());
+      }
+      return result;
+    }
+    if (probe.containerType() === "array") {
+      const length = probe.length();
+      for (let i = 0; i < length; i++) {
+        const constraint = probe.getIndex(i);
+        if (constraint && head.testConstraint(constraint)) {
+          result.push(new Descender(new Expression({
+            type: "index",
+            value: i
+          }), this.tail));
+        }
+      }
+      return result;
+    }
+    if (probe.containerType() === "object") {
+      if (head.constraintTargetIsSelf()) {
+        return [];
+      }
+      if (head.testConstraint(probe)) {
+        return this.descend();
+      }
+      return result;
+    }
+    return result;
+  }
+  descend() {
+    if (!this.tail) {
+      return [new Descender(null, null)];
+    }
+    return this.tail.descend().map(ht => {
+      return new Descender(ht.head, ht.tail);
+    });
+  }
+  toString() {
+    const result = ["<"];
+    if (this.head) {
+      result.push(this.head.toString());
+    }
+    result.push("|");
+    if (this.tail) {
+      result.push(this.tail.toString());
+    }
+    result.push(">");
+    return result.join("");
+  }
+}
+var __defProp$d = Object.defineProperty;
+var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __publicField$d = (obj, key, value) => {
+  __defNormalProp$d(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Matcher {
+  constructor(active, parent) {
+    __publicField$d(this, "active");
+    __publicField$d(this, "recursives");
+    __publicField$d(this, "payload");
+    this.active = active || [];
+    if (parent) {
+      this.recursives = parent.recursives;
+      this.payload = parent.payload;
+    } else {
+      this.recursives = [];
+    }
+    this.extractRecursives();
+  }
+  setPayload(payload) {
+    this.payload = payload;
+    return this;
+  }
+  // Moves any recursive descenders onto the recursive track, removing them from
+  // the active set
+  extractRecursives() {
+    this.active = this.active.filter(descender => {
+      if (descender.isRecursive()) {
+        this.recursives.push(...descender.extractRecursives());
+        return false;
+      }
+      return true;
+    });
+  }
+  // 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;
+      if (!head) {
+        return false;
+      }
+      if (head.isConstraint()) {
+        return true;
+      }
+      if (probe.containerType() === "array" && head.isIndexReference()) {
+        return true;
+      }
+      if (probe.containerType() === "object") {
+        return head.isAttributeReference() && probe.hasAttribute(head.name());
+      }
+      return false;
+    });
+  }
+  match(probe) {
+    return this.iterate(probe).extractMatches(probe);
+  }
+  iterate(probe) {
+    const newActiveSet = [];
+    this.active.concat(this.activeRecursives(probe)).forEach(descender => {
+      newActiveSet.push(...descender.iterate(probe));
+    });
+    return 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 = [];
+    const targets = [];
+    this.active.forEach(descender => {
+      if (descender.hasArrived()) {
+        targets.push(new Expression({
+          type: "alias",
+          target: "self"
+        }));
+        return;
+      }
+      const descenderHead = descender.head;
+      if (!descenderHead) {
+        return;
+      }
+      if (probe.containerType() === "array" && !descenderHead.isIndexReference()) {
+        return;
+      }
+      if (probe.containerType() === "object" && !descenderHead.isAttributeReference()) {
+        return;
+      }
+      if (descender.tail) {
+        const matcher = new Matcher(descender.descend(), this);
+        descenderHead.toFieldReferences().forEach(() => {
+          leads.push({
+            target: descenderHead,
+            matcher
+          });
+        });
+      } else {
+        targets.push(descenderHead);
+      }
+    });
+    if (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 if (probe.containerType() === "object") {
+        probe.attributeKeys().forEach(name => {
+          leads.push({
+            target: Expression.attributeReference(name),
+            matcher: recursivesMatcher
+          });
+        });
+      }
+    }
+    return targets.length > 0 ? {
+      leads,
+      delivery: {
+        targets,
+        payload: this.payload
+      }
+    } : {
+      leads
+    };
+  }
+  static fromPath(jsonpath) {
+    const path = parseJsonPath(jsonpath);
+    if (!path) {
+      throw new Error('Failed to parse path from "'.concat(jsonpath, '"'));
+    }
+    const descender = new Descender(null, new Expression(path));
+    return new Matcher(descender.descend());
+  }
+}
+function isRecord$1(value) {
+  return value !== null && typeof value === "object";
+}
+var __defProp$c = Object.defineProperty;
+var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __publicField$c = (obj, key, value) => {
+  __defNormalProp$c(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class PlainProbe {
+  constructor(value, path) {
+    __publicField$c(this, "_value");
+    __publicField$c(this, "path");
+    this._value = value;
+    this.path = path || [];
+  }
+  containerType() {
+    if (Array.isArray(this._value)) {
+      return "array";
+    } else if (this._value !== null && typeof this._value === "object") {
+      return "object";
+    }
+    return "primitive";
+  }
+  length() {
+    if (!Array.isArray(this._value)) {
+      throw new Error("Won't return length of non-indexable _value");
+    }
+    return this._value.length;
+  }
+  getIndex(i) {
+    if (!Array.isArray(this._value)) {
+      return false;
+    }
+    if (i >= this.length()) {
+      return null;
+    }
+    return new PlainProbe(this._value[i], this.path.concat(i));
+  }
+  hasAttribute(key) {
+    if (!isRecord$1(this._value)) {
+      return false;
+    }
+    return this._value.hasOwnProperty(key);
+  }
+  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");
+    }
+    if (!this.hasAttribute(key)) {
+      return null;
+    }
+    return new PlainProbe(this._value[key], this.path.concat(key));
+  }
+  get() {
+    return this._value;
+  }
+}
+function extractAccessors(path, value) {
+  const result = [];
+  const matcher = Matcher.fromPath(path).setPayload(function appendResult(values) {
+    result.push(...values);
+  });
+  const accessor = new PlainProbe(value);
+  descend(matcher, accessor);
+  return result;
+}
+function descend(matcher, accessor) {
+  const {
+    leads,
+    delivery
+  } = matcher.match(accessor);
+  leads.forEach(lead => {
+    accessorsFromTarget(lead.target, accessor).forEach(childAccessor => {
+      descend(lead.matcher, childAccessor);
+    });
+  });
+  if (delivery) {
+    delivery.targets.forEach(target => {
+      if (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 ".concat(target.toString()));
+  }
+  return compact$1(result);
+}
+function extractWithPath(path, value) {
+  const accessors = extractAccessors(path, value);
+  return accessors.map(acc => ({
+    path: acc.path,
+    value: acc.get()
+  }));
+}
+debugIt("mutator-document");
+const maxDepth = 6;
 function getTypeIcon(schemaType) {
   let t = schemaType;
   while (t) {
@@ -542,19 +4024,76 @@ function getFieldRefs(schemaType, parent) {
     const path = parent ? [...parent.path, field.name] : [field.name];
     const title = (_a = field.type.title) != null ? _a : field.name;
     const fieldRef = {
-      key: pathToString(path),
+      key: patchableKey(pathToString(path)),
       path,
       title: parent ? [parent.title, title].join(" / ") : title,
       schemaType: field.type,
       icon: getTypeIcon(field.type)
     };
     const fields = field.type.jsonType === "object" ? getFieldRefs(field.type, fieldRef, depth + 1) : [];
+    const syntheticFields = field.type.jsonType === "array" ? getSyntheticFields(field.type, fieldRef, depth + 1) : [];
     if (!isAssistSupported(field.type, true)) {
+      return [...fields, ...syntheticFields];
+    }
+    return [fieldRef, ...fields, ...syntheticFields];
+  });
+}
+function getSyntheticFields(schemaType, parent) {
+  let depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  if (depth >= maxDepth) {
+    return [];
+  }
+  return schemaType.of.filter(itemType => !isType(itemType, "block")).flatMap(itemType => {
+    var _a;
+    const segment = {
+      _key: itemType.name
+    };
+    const title = (_a = itemType.title) != null ? _a : itemType.name;
+    const path = parent ? [...parent.path, segment] : [segment];
+    const fieldRef = {
+      key: patchableKey(pathToString(path)),
+      path,
+      title: parent ? [parent.title, title].join(" / ") : title,
+      schemaType: itemType,
+      icon: getTypeIcon(itemType),
+      synthetic: true
+    };
+    const fields = itemType.jsonType === "object" ? getFieldRefs(itemType, fieldRef, depth + 1) : [];
+    if (!isAssistSupported(itemType, true)) {
       return fields;
     }
     return [fieldRef, ...fields];
   });
 }
+function getTypePath(doc, pathString) {
+  if (!pathString) {
+    return void 0;
+  }
+  const path = stringToPath(pathString);
+  const currentPath = [];
+  let valid = true;
+  const syntheticPath = path.map(segment => {
+    currentPath.push(segment);
+    if (isKeySegment(segment)) {
+      const match = extractWithPath(pathToString(currentPath), doc)[0];
+      const value = match == null ? void 0 : match.value;
+      if (match && value && typeof value === "object" && "_type" in value) {
+        return {
+          _key: value._type
+        };
+      }
+      valid = false;
+    }
+    return segment;
+  });
+  return valid ? patchableKey(pathToString(syntheticPath)) : void 0;
+}
+function patchableKey(pathKey) {
+  return pathKey.replace(/[=]=/g, ":").replace(/[[\]]/g, "|").replace(/"/g, "");
+}
+function useTypePath(doc, pathString) {
+  return useMemo(() => getTypePath(doc, pathString), [doc, pathString]);
+}
 function useSelectedField(documentSchemaType, path) {
   const selectableFields = useMemo(() => documentSchemaType && isObjectSchemaType(documentSchemaType) ? getFieldRefsWithDocument(documentSchemaType) : [], [documentSchemaType]);
   return useMemo(() => {
@@ -562,9 +4101,9 @@ function useSelectedField(documentSchemaType, path) {
   }, [selectableFields, path]);
 }
 function getFieldTitle(field) {
-  var _a, _b;
+  var _a, _b, _c;
   const schemaType = field == null ? void 0 : field.schemaType;
-  return (_b = (_a = schemaType == null ? void 0 : schemaType.title) != null ? _a : schemaType == null ? void 0 : schemaType.name) != null ? _b : "Untitled";
+  return (_c = (_b = (_a = field == null ? void 0 : field.title) != null ? _a : schemaType == null ? void 0 : schemaType.title) != null ? _b : schemaType == null ? void 0 : schemaType.name) != null ? _c : "Untitled";
 }
 function useAiPaneRouter() {
   const paneRouter = usePaneRouter();
@@ -836,7 +4375,7 @@ function TaskList(props) {
       onEscape();
     }
   }, [isTopLayer, onEscape]));
-  return /* @__PURE__ */jsx(Stack, {
+  return /* @__PURE__ */jsx(Stack$1, {
     padding: 1,
     space: 1,
     children: tasks.map(task => /* @__PURE__ */jsx(TaskItem, {
@@ -867,7 +4406,7 @@ function TaskItem(props) {
             size: 1,
             children: [taskType && createElement(taskType.icon), !task.reason && /* @__PURE__ */jsx(Spinner, {})]
           })
-        }), /* @__PURE__ */jsxs(Stack, {
+        }), /* @__PURE__ */jsxs(Stack$1, {
           flex: 1,
           space: 2,
           children: [/* @__PURE__ */jsxs(Text, {
@@ -1209,7 +4748,7 @@ function RunInstructionProvider(props) {
           })
         }) : runButton
       }),
-      children: /* @__PURE__ */jsx(Stack, {
+      children: /* @__PURE__ */jsx(Stack$1, {
         padding: 4,
         space: 2,
         children: (_a = runRequest == null ? void 0 : runRequest.userInputBlocks) == null ? void 0 : _a.map((block, i) => /* @__PURE__ */jsx(UserInput, {
@@ -1251,7 +4790,7 @@ function UserInput(props) {
       return (_a2 = textAreaRef.current) == null ? void 0 : _a2.focus();
     }, 0);
   }, [autoFocus]);
-  return /* @__PURE__ */jsxs(Stack, {
+  return /* @__PURE__ */jsxs(Stack$1, {
     padding: 2,
     space: 3,
     children: [/* @__PURE__ */jsx(FormFieldHeaderText, {
@@ -1268,114 +4807,420 @@ function UserInput(props) {
     })]
   });
 }
-function isDocAssistable(documentSchemaType, published, draft) {
-  return !!(documentSchemaType.liveEdit ? published : draft);
-}
-function getAssistableDocId(documentSchemaType, documentId) {
-  const baseId = publicId(documentId);
-  return documentSchemaType.liveEdit ? baseId : "drafts.".concat(baseId);
+function isDocAssistable(documentSchemaType, published, draft) {
+  return !!(documentSchemaType.liveEdit ? published : draft);
+}
+function getAssistableDocId(documentSchemaType, documentId) {
+  const baseId = publicId(documentId);
+  return documentSchemaType.liveEdit ? baseId : "drafts.".concat(baseId);
+}
+function useRequestRunInstruction(args) {
+  const {
+    documentOnChange,
+    isDocAssistable: isDocAssistable2
+  } = args;
+  const {
+    runInstruction,
+    instructionLoading
+  } = useRunInstruction();
+  const [queuedTask, setQueuedTask] = useState(void 0);
+  useEffect(() => {
+    if (queuedTask && isDocAssistable2) {
+      runInstruction(queuedTask);
+      setQueuedTask(void 0);
+    }
+  }, [queuedTask, isDocAssistable2, runInstruction]);
+  return {
+    instructionLoading,
+    requestRunInstruction: useCallback(task => {
+      documentOnChange(PatchEvent.from([unset(["_force_document_creation"])]));
+      setQueuedTask(task);
+    }, [setQueuedTask, documentOnChange])
+  };
+}
+const SparklesIllustration = styled(SparklesIcon)({
+  fontSize: "3.125em",
+  "& path": {
+    strokeWidth: "0.6px !important"
+  }
+});
+function InspectorOnboarding(props) {
+  const {
+    onDismiss
+  } = props;
+  return /* @__PURE__ */jsx(Box, {
+    padding: 4,
+    children: /* @__PURE__ */jsx(Container, {
+      width: 0,
+      children: /* @__PURE__ */jsxs(Stack$1, {
+        space: 4,
+        children: [/* @__PURE__ */jsx("div", {
+          style: {
+            textAlign: "center"
+          },
+          children: /* @__PURE__ */jsx(SparklesIllustration, {})
+        }), /* @__PURE__ */jsx(Text, {
+          align: "center",
+          size: 1,
+          children: "Create reusable AI instructions that can be applied across all documents of a certain type."
+        }), /* @__PURE__ */jsxs(Flex, {
+          align: "center",
+          gap: 2,
+          justify: "center",
+          children: [/* @__PURE__ */jsx(Button, {
+            as: "a",
+            href: releaseAnnouncementUrl,
+            rel: "noreferrer",
+            target: "_blank",
+            fontSize: 1,
+            mode: "default",
+            onClick: onDismiss,
+            padding: 2,
+            text: "Learn more",
+            tone: "primary"
+          }), /* @__PURE__ */jsx(Button, {
+            fontSize: 1,
+            mode: "bleed",
+            onClick: onDismiss,
+            padding: 2,
+            text: "Dismiss"
+          })]
+        })]
+      })
+    })
+  });
+}
+const inspectorOnboardingKey = "sanityStudio:assist:inspector:onboarding:dismissed";
+const fieldOnboardingKey = "sanityStudio:assist:field:onboarding:dismissed";
+function isFeatureOnboardingDismissed(featureKey) {
+  if (typeof localStorage === "undefined") {
+    return false;
+  }
+  const value = localStorage.getItem(featureKey);
+  return value === "true";
+}
+function dismissFeatureOnboarding(featureKey) {
+  if (typeof localStorage === "undefined") {
+    return;
+  }
+  localStorage.setItem(featureKey, "true");
+}
+function useOnboardingFeature(featureKey) {
+  const [showOnboarding, setShowOnboarding] = useState(() => !isFeatureOnboardingDismissed(featureKey));
+  const dismissOnboarding = useCallback(() => {
+    setShowOnboarding(false);
+    dismissFeatureOnboarding(featureKey);
+  }, [setShowOnboarding, featureKey]);
+  return {
+    showOnboarding,
+    dismissOnboarding
+  };
+}
+function BackToInstructionListLink() {
+  const {
+    openInspector
+  } = useDocumentPane();
+  const goBack = useCallback(() => openInspector(aiInspectorId, {
+    [instructionParam]: void 0
+  }), [openInspector]);
+  return /* @__PURE__ */jsx("div", {
+    children: /* @__PURE__ */jsx(Button, {
+      as: "a",
+      fontSize: 1,
+      icon: ArrowLeftIcon,
+      mode: "bleed",
+      padding: 1,
+      space: 2,
+      onClick: goBack,
+      text: "  Instructions",
+      textAlign: "left"
+    })
+  });
+}
+const EMPTY_FIELDS = [];
+const TypePathContext = createContext(void 0);
+function AssistDocumentForm(props) {
+  const {
+    onChange
+  } = props;
+  const value = props.value;
+  const id = value == null ? void 0 : value._id;
+  const fields = value == null ? void 0 : value.fields;
+  const targetDocumentType = useMemo(() => {
+    if (!id) {
+      return void 0;
+    }
+    return documentTypeFromAiDocumentId(id);
+  }, [id]);
+  const {
+    params,
+    setParams
+  } = useAiPaneRouter();
+  const pathKey = params[fieldPathParam];
+  const typePath = useContext(TypePathContext);
+  const instruction = params[instructionParam];
+  const activeKey = useMemo(() => {
+    var _a;
+    if (!typePath) {
+      return void 0;
+    }
+    return (_a = (fields != null ? fields : EMPTY_FIELDS).find(f => f.path === typePath)) == null ? void 0 : _a._key;
+  }, [fields, typePath]);
+  const activePath = useMemo(() => {
+    if (!activeKey) {
+      return void 0;
+    }
+    const base = ["fields", {
+      _key: activeKey
+    }];
+    return instruction ? [...base, "instructions", {
+      _key: instruction
+    }] : base;
+  }, [activeKey, instruction]);
+  const schema = useSchema();
+  const documentSchema = useMemo(() => {
+    if (!targetDocumentType) {
+      return void 0;
+    }
+    return schema.get(targetDocumentType);
+  }, [schema, targetDocumentType]);
+  const fieldSchema = useSelectedSchema(pathKey, documentSchema);
+  const context = useMemo(() => ({
+    documentSchema,
+    fieldSchema: fieldSchema != null ? fieldSchema : documentSchema
+  }), [fieldSchema, documentSchema]);
+  const title = value == null ? void 0 : value.title;
+  useEffect(() => {
+    var _a;
+    if (!title && documentSchema && !(id == null ? void 0 : id.startsWith("drafts."))) {
+      onChange(set((_a = documentSchema.title) != null ? _a : documentSchema.name, ["title"]));
+    }
+  }, [title, documentSchema, onChange, id]);
+  const fieldExists = !!(fields == null ? void 0 : fields.some(f => f._key === typePath));
+  const {
+    onPathOpen,
+    ...formCallbacks
+  } = useFormCallbacks();
+  const newCallbacks = useMemo(() => ({
+    ...formCallbacks,
+    onPathOpen: path => {
+      var _a;
+      if (!instruction && path.length === 4 && path[2] === "instructions") {
+        setParams(typed({
+          ...params,
+          [instructionParam]: (_a = path[3]) == null ? void 0 : _a._key
+        }));
+        onPathOpen([]);
+      } else {
+        setTimeout(() => onPathOpen(path), 0);
+      }
+    }
+  }), [formCallbacks, onPathOpen, params, setParams, instruction]);
+  useEffect(() => {
+    if (activePath && !instruction) {
+      onPathOpen([]);
+    }
+  }, [activePath, instruction, onPathOpen]);
+  return /* @__PURE__ */jsx(SelectedFieldContextProvider, {
+    value: context,
+    children: /* @__PURE__ */jsxs(Stack$1, {
+      space: 5,
+      children: [/* @__PURE__ */jsx(FieldsInitializer, {
+        pathKey: typePath,
+        activePath,
+        fieldExists,
+        onChange
+      }, typePath), instruction && /* @__PURE__ */jsx(BackToInstructionListLink, {}), activePath && /* @__PURE__ */jsx(FormCallbacksProvider, {
+        ...newCallbacks,
+        children: /* @__PURE__ */jsx("div", {
+          style: {
+            lineHeight: "1.25em"
+          },
+          children: /* @__PURE__ */jsx(FormInput, {
+            ...props,
+            absolutePath: activePath
+          })
+        })
+      }), !activePath && props.renderDefault(props)]
+    })
+  });
+}
+function useSelectedSchema(fieldPath, documentSchema) {
+  return useMemo(() => {
+    if (!fieldPath) {
+      return void 0;
+    }
+    if (fieldPath === documentRootKey) {
+      return documentSchema;
+    }
+    const path = stringToPath(fieldPath);
+    let currentSchema = documentSchema;
+    for (let i = 0; i < path.length; i++) {
+      const segment = path[i];
+      const field = currentSchema == null ? void 0 : currentSchema.fields.find(f => f.name === segment);
+      if (!field) {
+        return void 0;
+      }
+      if (i === path.length - 1) {
+        return field.type;
+      }
+      if (field.type.jsonType !== "object") {
+        return void 0;
+      }
+      currentSchema = field.type;
+    }
+    return currentSchema;
+  }, [documentSchema, fieldPath]);
 }
-function useRequestRunInstruction(args) {
-  const {
-    documentOnChange,
-    isDocAssistable: isDocAssistable2
-  } = args;
-  const {
-    runInstruction,
-    instructionLoading
-  } = useRunInstruction();
-  const [queuedTask, setQueuedTask] = useState(void 0);
+function FieldsInitializer(_ref7) {
+  let {
+    pathKey,
+    activePath,
+    fieldExists,
+    onChange
+  } = _ref7;
+  const initialized = useRef(false);
   useEffect(() => {
-    if (queuedTask && isDocAssistable2) {
-      runInstruction(queuedTask);
-      setQueuedTask(void 0);
+    if (initialized.current || fieldExists || activePath || !pathKey) {
+      return;
     }
-  }, [queuedTask, isDocAssistable2, runInstruction]);
-  return {
-    instructionLoading,
-    requestRunInstruction: useCallback(task => {
-      documentOnChange(PatchEvent.from([unset(["_force_document_creation"])]));
-      setQueuedTask(task);
-    }, [setQueuedTask, documentOnChange])
-  };
+    onChange([setIfMissing([], ["fields"]), insert([typed({
+      _key: pathKey,
+      _type: assistFieldTypeName,
+      path: pathKey
+    })], "after", ["fields", -1])]);
+    initialized.current = true;
+  }, [activePath, onChange, pathKey, fieldExists]);
+  return null;
 }
-const SparklesIllustration = styled(SparklesIcon)({
-  fontSize: "3.125em",
-  "& path": {
-    strokeWidth: "0.6px !important"
-  }
-});
-function InspectorOnboarding(props) {
+function FieldAutocomplete(props) {
   const {
-    onDismiss
+    id,
+    schemaType,
+    fieldPath,
+    onSelect,
+    includeDocument,
+    filter
   } = props;
-  return /* @__PURE__ */jsx(Box, {
-    padding: 4,
-    children: /* @__PURE__ */jsx(Container, {
-      width: 0,
-      children: /* @__PURE__ */jsxs(Stack, {
-        space: 4,
-        children: [/* @__PURE__ */jsx("div", {
-          style: {
-            textAlign: "center"
-          },
-          children: /* @__PURE__ */jsx(SparklesIllustration, {})
-        }), /* @__PURE__ */jsx(Text, {
-          align: "center",
+  const fieldRefs = useMemo(() => {
+    if (includeDocument) {
+      return getFieldRefsWithDocument(schemaType);
+    }
+    return getFieldRefs(schemaType);
+  }, [schemaType, includeDocument]);
+  const currentField = useMemo(() => fieldRefs.find(f => f.key === fieldPath), [fieldPath, fieldRefs]);
+  const autocompleteOptions = useMemo(() => fieldRefs.filter(field => filter ? filter(field) : true).map(field => ({
+    value: field.key,
+    field
+  })), [fieldRefs, filter]);
+  const renderOption = useCallback(option => {
+    const {
+      value,
+      field
+    } = option;
+    if (!value) {
+      return /* @__PURE__ */jsx(Card, {
+        as: "button",
+        padding: 3,
+        radius: 1,
+        children: /* @__PURE__ */jsx(Text, {
+          accent: true,
           size: 1,
-          children: "Create reusable AI instructions that can be applied across all documents of a certain type."
-        }), /* @__PURE__ */jsxs(Flex, {
-          align: "center",
-          gap: 2,
-          justify: "center",
-          children: [/* @__PURE__ */jsx(Button, {
-            as: "a",
-            href: releaseAnnouncementUrl,
-            rel: "noreferrer",
-            target: "_blank",
-            fontSize: 1,
-            mode: "default",
-            onClick: onDismiss,
-            padding: 2,
-            text: "Learn more",
-            tone: "primary"
-          }), /* @__PURE__ */jsx(Button, {
-            fontSize: 1,
-            mode: "bleed",
-            onClick: onDismiss,
-            padding: 2,
-            text: "Dismiss"
-          })]
+          children: option.value
+        })
+      });
+    }
+    if (isType(field.schemaType, "document")) {
+      return /* @__PURE__ */jsx(Card, {
+        as: "button",
+        padding: 3,
+        radius: 1,
+        children: /* @__PURE__ */jsx(Text, {
+          size: 1,
+          weight: "semibold",
+          children: "The entire document"
+        })
+      });
+    }
+    return /* @__PURE__ */jsx(Card, {
+      as: "button",
+      padding: 3,
+      radius: 1,
+      children: /* @__PURE__ */jsxs(Flex, {
+        gap: 3,
+        children: [/* @__PURE__ */jsx(Text, {
+          size: 1,
+          children: createElement(field.icon)
+        }), /* @__PURE__ */jsx(FieldTitle, {
+          field
         })]
       })
-    })
+    });
+  }, []);
+  const renderValue = useCallback((value, option) => {
+    var _a;
+    return (_a = option == null ? void 0 : option.field.title) != null ? _a : value;
+  }, []);
+  const filterOption = useCallback((query, option) => {
+    var _a, _b, _c;
+    const lQuery = query.toLowerCase();
+    return ((_a = option == null ? void 0 : option.value) == null ? void 0 : _a.toLowerCase().includes(lQuery)) || ((_c = (_b = option == null ? void 0 : option.field) == null ? void 0 : _b.title) == null ? void 0 : _c.toLowerCase().includes(lQuery));
+  }, []);
+  return /* @__PURE__ */jsx(Autocomplete, {
+    fontSize: 1,
+    icon: currentField ? currentField.icon : SearchIcon,
+    onChange: onSelect,
+    openButton: true,
+    id,
+    options: autocompleteOptions,
+    placeholder: "Search for a field",
+    radius: 2,
+    renderOption,
+    renderValue,
+    value: currentField == null ? void 0 : currentField.key,
+    filterOption
   });
 }
-const inspectorOnboardingKey = "sanityStudio:assist:inspector:onboarding:dismissed";
-const fieldOnboardingKey = "sanityStudio:assist:field:onboarding:dismissed";
-function isFeatureOnboardingDismissed(featureKey) {
-  if (typeof localStorage === "undefined") {
-    return false;
-  }
-  const value = localStorage.getItem(featureKey);
-  return value === "true";
-}
-function dismissFeatureOnboarding(featureKey) {
-  if (typeof localStorage === "undefined") {
-    return;
-  }
-  localStorage.setItem(featureKey, "true");
-}
-function useOnboardingFeature(featureKey) {
-  const [showOnboarding, setShowOnboarding] = useState(() => !isFeatureOnboardingDismissed(featureKey));
-  const dismissOnboarding = useCallback(() => {
-    setShowOnboarding(false);
-    dismissFeatureOnboarding(featureKey);
-  }, [setShowOnboarding, featureKey]);
-  return {
-    showOnboarding,
-    dismissOnboarding
-  };
+function FieldTitle(props) {
+  const splitTitle = props.field.title.split("/");
+  return /* @__PURE__ */jsx(Box, {
+    flex: "none",
+    children: /* @__PURE__ */jsxs(Breadcrumbs, {
+      style: {
+        display: "flex",
+        flexWrap: "wrap",
+        alignItems: "center",
+        marginTop: "-4px"
+      },
+      separator: /* @__PURE__ */jsx(Box, {
+        marginTop: 1,
+        children: /* @__PURE__ */jsx(Text, {
+          muted: true,
+          size: 1,
+          children: "/"
+        })
+      }),
+      space: 1,
+      children: [splitTitle.slice(0, splitTitle.length - 1).map((pt, i) =>
+      // eslint-disable-next-line react/no-array-index-key
+      /* @__PURE__ */
+      jsx(Box, {
+        marginTop: 1,
+        children: /* @__PURE__ */jsx(Text, {
+          muted: true,
+          size: 1,
+          children: pt.trim()
+        })
+      }, i)), /* @__PURE__ */jsx(Box, {
+        marginTop: 1,
+        children: /* @__PURE__ */jsx(Text, {
+          size: 1,
+          weight: "medium",
+          children: splitTitle[splitTitle.length - 1]
+        })
+      })]
+    })
+  });
 }
 var __freeze$4 = Object.freeze;
 var __defProp$4 = Object.defineProperty;
@@ -1394,7 +5239,7 @@ function AssistInspectorWrapper(props) {
       justify: "center",
       padding: 4,
       sizing: "border",
-      children: /* @__PURE__ */jsxs(Stack, {
+      children: /* @__PURE__ */jsxs(Stack$1, {
         space: 3,
         style: {
           textAlign: "center"
@@ -1418,7 +5263,7 @@ function AssistInspectorWrapper(props) {
         closeButtonLabel: "Close",
         onClose: props.onClose,
         title: pluginTitle
-      }), /* @__PURE__ */jsxs(Stack, {
+      }), /* @__PURE__ */jsxs(Stack$1, {
         flex: 1,
         overflow: "auto",
         padding: 4,
@@ -1455,7 +5300,7 @@ function AssistInspectorWrapper(props) {
         closeButtonLabel: "Close",
         onClose: props.onClose,
         title: pluginTitle
-      }), /* @__PURE__ */jsxs(Stack, {
+      }), /* @__PURE__ */jsxs(Stack$1, {
         padding: 4,
         space: 3,
         children: [context.error ? /* @__PURE__ */jsxs(Text, {
@@ -1514,6 +5359,7 @@ function AssistInspector(props) {
   const {
     documentId,
     documentType,
+    value: docValue,
     schemaType,
     onChange: documentOnChange
   } = documentPane;
@@ -1529,13 +5375,14 @@ function AssistInspector(props) {
     documentOnChange,
     isDocAssistable: isDocAssistable(schemaType, published, draft)
   });
-  const selectedField = useSelectedField(schemaType, params[fieldPathParam]);
+  const typePath = useTypePath(docValue, pathKey != null ? pathKey : "");
+  const selectedField = useSelectedField(schemaType, typePath);
   const aiDocId = assistDocumentId(documentType);
   const assistDocument = useStudioAssistDocument({
     documentId,
     schemaType
   });
-  const assistField = (_a2 = assistDocument == null ? void 0 : assistDocument.fields) == null ? void 0 : _a2.find(f => f.path === pathKey);
+  const assistField = (_a2 = assistDocument == null ? void 0 : assistDocument.fields) == null ? void 0 : _a2.find(f => f.path === typePath);
   const instruction = (_b2 = assistField == null ? void 0 : assistField.instructions) == null ? void 0 : _b2.find(i => i._key === instructionKey);
   const tasks = useMemo(() => {
     var _a3;
@@ -1567,12 +5414,13 @@ function AssistInspector(props) {
       type: assistDocumentTypeName
     }
   }), [aiDocId]);
-  const runCurrentInstruction = useCallback(() => instruction && pathKey && requestRunInstruction({
+  const runCurrentInstruction = useCallback(() => instruction && pathKey && typePath && requestRunInstruction({
     documentId: assistableDocId,
     path: pathKey,
+    typePath,
     assistDocumentId: assistDocumentId(documentType),
     instruction
-  }), [instruction, pathKey, documentType, assistableDocId, requestRunInstruction]);
+  }), [pathKey, instruction, typePath, documentType, assistableDocId, requestRunInstruction]);
   const Region = useCallback(_props => {
     return /* @__PURE__ */jsx("div", {
       ..._props,
@@ -1603,6 +5451,7 @@ function AssistInspector(props) {
     },
     children: [/* @__PURE__ */jsx(AiInspectorHeader, {
       onClose: props.onClose,
+      field: selectedField,
       fieldTitle: getFieldTitle(selectedField)
     }), /* @__PURE__ */jsx(Card, {
       as: Region,
@@ -1618,15 +5467,18 @@ function AssistInspector(props) {
           children: /* @__PURE__ */jsx(PresenceOverlay, {
             children: /* @__PURE__ */jsx(Box, {
               padding: 4,
-              children: selectedField && /* @__PURE__ */jsx(VirtualizerScrollInstanceProvider, {
-                scrollElement: boundary.current,
-                containerElement: boundary,
-                children: /* @__PURE__ */jsx(DocumentPaneProvider, {
-                  paneKey: documentPane.paneKey,
-                  index: documentPane.index,
-                  itemId: "ai",
-                  pane: paneNode,
-                  children: /* @__PURE__ */jsx(DocumentForm, {})
+              children: selectedField && /* @__PURE__ */jsx(TypePathContext.Provider, {
+                value: typePath,
+                children: /* @__PURE__ */jsx(VirtualizerScrollInstanceProvider, {
+                  scrollElement: boundary.current,
+                  containerElement: boundary,
+                  children: /* @__PURE__ */jsx(DocumentPaneProvider, {
+                    paneKey: documentPane.paneKey,
+                    index: documentPane.index,
+                    itemId: "ai",
+                    pane: paneNode,
+                    children: /* @__PURE__ */jsx(DocumentForm, {})
+                  })
                 })
               })
             })
@@ -1660,7 +5512,7 @@ function AssistInspector(props) {
         gap: 2,
         flex: 1,
         justify: "flex-end",
-        children: [(schemaType == null ? void 0 : schemaType.name) && pathKey && instructionKey && /* @__PURE__ */jsx(Stack, {
+        children: [(schemaType == null ? void 0 : schemaType.name) && pathKey && instructionKey && /* @__PURE__ */jsx(Stack$1, {
           flex: 1,
           children: /* @__PURE__ */jsx(Button, {
             mode: "ghost",
@@ -1684,6 +5536,7 @@ function AssistInspector(props) {
 function AiInspectorHeader(props) {
   const {
     onClose,
+    field,
     fieldTitle
   } = props;
   const {
@@ -1704,18 +5557,25 @@ function AiInspectorHeader(props) {
         children: /* @__PURE__ */jsxs(Flex, {
           gap: 1,
           align: "center",
-          children: [/* @__PURE__ */jsx(Text, {
-            size: 1,
-            weight: "semibold",
-            children: "AI instructions for"
+          wrap: "wrap",
+          style: {
+            marginTop: "-4px"
+          },
+          children: [/* @__PURE__ */jsx(Box, {
+            marginTop: 1,
+            children: /* @__PURE__ */jsx(Text, {
+              size: 1,
+              weight: "semibold",
+              children: "AI instructions for"
+            })
           }), /* @__PURE__ */jsx(Card, {
             radius: 2,
             border: true,
             padding: 1,
-            style: {
-              margin: "-4px 0"
-            },
-            children: /* @__PURE__ */jsx(Text, {
+            marginTop: 1,
+            children: field ? /* @__PURE__ */jsx(FieldTitle, {
+              field
+            }) : /* @__PURE__ */jsx(Text, {
               size: 1,
               weight: "semibold",
               children: fieldTitle
@@ -1745,10 +5605,10 @@ const assistInspector = {
     showAsAction: false
   }),
   component: AssistInspectorWrapper,
-  onClose(_ref7) {
+  onClose(_ref8) {
     let {
       params
-    } = _ref7;
+    } = _ref8;
     return {
       params: typed({
         ...params,
@@ -1821,11 +5681,11 @@ var __template$3 = (cooked, raw) => __freeze$3(__defProp$3(cooked, "raw", {
 var _a$3, _b$1;
 const fadeIn = 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.div(_b$1 || (_b$1 = __template$3(["\n  animation-name: ", ";\n  animation-timing-function: ease-in-out;\n"])), fadeIn);
-const FadeInContent = forwardRef(function FadeInContent2(_ref8, ref) {
+const FadeInContent = forwardRef(function FadeInContent2(_ref9, ref) {
   let {
     children,
     durationMs = 250
-  } = _ref8;
+  } = _ref9;
   return /* @__PURE__ */jsx(FadeInDiv, {
     ref,
     style: {
@@ -2004,11 +5864,11 @@ function AssistOnboardingPopover(props) {
 }
 function AssistIntroCard(props) {
   const buttonRef = useRef(null);
-  return /* @__PURE__ */jsxs(Stack, {
+  return /* @__PURE__ */jsxs(Stack$1, {
     as: "section",
     padding: 3,
     space: 3,
-    children: [/* @__PURE__ */jsxs(Stack, {
+    children: [/* @__PURE__ */jsxs(Stack$1, {
       padding: 2,
       space: 4,
       children: [/* @__PURE__ */jsxs(Flex, {
@@ -2027,7 +5887,7 @@ function AssistIntroCard(props) {
           },
           children: /* @__PURE__ */jsx(AssistFeatureBadge, {})
         })]
-      }), /* @__PURE__ */jsx(Stack, {
+      }), /* @__PURE__ */jsx(Stack$1, {
         space: 3,
         children: /* @__PURE__ */jsxs(Text, {
           as: "p",
@@ -2651,7 +6511,7 @@ function AlphaMigration() {
       header: pluginTitle,
       children: /* @__PURE__ */jsx(Card, {
         padding: 3,
-        children: /* @__PURE__ */jsxs(Stack, {
+        children: /* @__PURE__ */jsxs(Stack$1, {
           space: 4,
           style: {
             maxWidth: 500
@@ -2834,307 +6694,135 @@ function AssistLayout(props) {
 }
 var __freeze$1 = Object.freeze;
 var __defProp$1 = Object.defineProperty;
-var __template$1 = (cooked, raw) => __freeze$1(__defProp$1(cooked, "raw", {
-  value: __freeze$1(raw || cooked.slice())
-}));
-var _a$1;
-const WrapPreCard = styled(Card)(_a$1 || (_a$1 = __template$1(["\n  & pre {\n    white-space: pre-wrap !important;\n  }\n"])));
-function SafeValueInput(props) {
-  return /* @__PURE__ */jsx(ErrorWrapper, {
-    onChange: props.onChange,
-    children: /* @__PURE__ */jsx(PteValueFixer, {
-      ...props
-    })
-  });
-}
-function ErrorWrapper(props) {
-  const {
-    onChange
-  } = props;
-  const [error, setError] = useState();
-  const catchError = useCallback(params => {
-    setError(params.error);
-  }, [setError]);
-  const unsetValue = useCallback(() => onChange(PatchEvent.from(unset())), [onChange]);
-  const dismiss = useCallback(() => setError(void 0), []);
-  const catcher = /* @__PURE__ */jsx(ErrorBoundary, {
-    onCatch: catchError,
-    children: props.children
-  });
-  return error ? /* @__PURE__ */jsx(Card, {
-    border: true,
-    tone: "critical",
-    padding: 2,
-    contentEditable: false,
-    children: /* @__PURE__ */jsxs(Stack, {
-      space: 3,
-      children: [/* @__PURE__ */jsx(Text, {
-        muted: true,
-        weight: "semibold",
-        children: "An error occurred."
-      }), /* @__PURE__ */jsx(WrapPreCard, {
-        flex: 1,
-        padding: 2,
-        tone: "critical",
-        border: true,
-        children: catcher
-      }), /* @__PURE__ */jsxs(Flex, {
-        width: "fill",
-        flex: 1,
-        gap: 3,
-        children: [/* @__PURE__ */jsx(Box, {
-          flex: 1,
-          children: /* @__PURE__ */jsx(Button, {
-            text: "Dismiss",
-            onClick: dismiss,
-            tone: "primary"
-          })
-        }), /* @__PURE__ */jsx(Button, {
-          text: "Unset value",
-          onClick: unsetValue,
-          tone: "critical"
-        })]
-      })]
-    })
-  }) : catcher;
-}
-function PteValueFixer(props) {
-  const isPortableText = useMemo(() => isArraySchemaType(props.schemaType) && isPortableTextArray(props.schemaType), [props.schemaType]);
-  const value = props.value;
-  if (isPortableText && value && !value.length) {
-    return props.renderDefault({
-      ...props,
-      value: void 0
-    });
-  }
-  return props.renderDefault(props);
-}
-function AssistFormBlock(props) {
-  const presence = useAssistPresence(props.path, true);
-  const {
-    onChange
-  } = useFormCallbacks();
-  const key = props.value._key;
-  const localOnChange = useCallback(patchEvent => {
-    if (!key) {
-      return;
-    }
-    onChange(PatchEvent.from(patchEvent).prefixAll({
-      _key: key
-    }));
-  }, [onChange, key]);
-  return /* @__PURE__ */jsx(ErrorWrapper, {
-    onChange: localOnChange,
-    children: /* @__PURE__ */jsxs(Flex, {
-      align: "center",
-      justify: "space-between",
-      children: [/* @__PURE__ */jsx(Box, {
-        flex: 1,
-        children: props.renderDefault(props)
-      }), presence.map(pre => /* @__PURE__ */jsx(AiFieldPresence, {
-        presence: pre
-      }, pre.lastActiveAt))]
-    })
-  });
-}
-function AssistItem(props) {
-  const {
-    path
-  } = props;
-  const presence = useAssistPresence(path, true);
-  return /* @__PURE__ */jsxs(Flex, {
-    align: "center",
-    width: "fill",
-    style: {
-      position: "relative"
-    },
-    children: [/* @__PURE__ */jsx(Box, {
-      flex: 1,
-      children: props.renderDefault({
-        ...props
-      })
-    }), presence.map(pre => /* @__PURE__ */jsx(Box, {
-      style: {
-        position: "absolute",
-        right: 35
-      },
-      children: /* @__PURE__ */jsx(AiFieldPresence, {
-        presence: pre
-      })
-    }, pre.user.id))]
-  });
-}
-function BackToInstructionListLink() {
-  const {
-    openInspector
-  } = useDocumentPane();
-  const goBack = useCallback(() => openInspector(aiInspectorId, {
-    [instructionParam]: void 0
-  }), [openInspector]);
-  return /* @__PURE__ */jsx("div", {
-    children: /* @__PURE__ */jsx(Button, {
-      as: "a",
-      fontSize: 1,
-      icon: ArrowLeftIcon,
-      mode: "bleed",
-      padding: 1,
-      space: 2,
-      onClick: goBack,
-      text: "  Instructions",
-      textAlign: "left"
-    })
-  });
-}
-const EMPTY_FIELDS = [];
-function AssistDocumentForm(props) {
-  const {
-    onChange
-  } = props;
-  const value = props.value;
-  const id = value == null ? void 0 : value._id;
-  const fields = value == null ? void 0 : value.fields;
-  const targetDocumentType = useMemo(() => {
-    if (!id) {
-      return void 0;
-    }
-    return documentTypeFromAiDocumentId(id);
-  }, [id]);
-  const {
-    params,
-    setParams
-  } = useAiPaneRouter();
-  const pathKey = params[fieldPathParam];
-  const instruction = params[instructionParam];
-  const activeKey = useMemo(() => {
-    var _a;
-    return (_a = (fields != null ? fields : EMPTY_FIELDS).find(f => f.path === pathKey)) == null ? void 0 : _a._key;
-  }, [fields, pathKey]);
-  const activePath = useMemo(() => {
-    if (!activeKey) {
-      return void 0;
-    }
-    const base = ["fields", {
-      _key: activeKey
-    }];
-    return instruction ? [...base, "instructions", {
-      _key: instruction
-    }] : base;
-  }, [activeKey, instruction]);
-  const schema = useSchema();
-  const documentSchema = useMemo(() => {
-    if (!targetDocumentType) {
-      return void 0;
-    }
-    return schema.get(targetDocumentType);
-  }, [schema, targetDocumentType]);
-  const fieldSchema = useSelectedSchema(pathKey, documentSchema);
-  const context = useMemo(() => ({
-    documentSchema,
-    fieldSchema: fieldSchema != null ? fieldSchema : documentSchema
-  }), [fieldSchema, documentSchema]);
-  const title = value == null ? void 0 : value.title;
-  useEffect(() => {
-    var _a;
-    if (!title && documentSchema && !(id == null ? void 0 : id.startsWith("drafts."))) {
-      onChange(set((_a = documentSchema.title) != null ? _a : documentSchema.name, ["title"]));
-    }
-  }, [title, documentSchema, onChange, id]);
-  const fieldExists = !!(fields == null ? void 0 : fields.some(f => f._key === pathKey));
-  const {
-    onPathOpen,
-    ...formCallbacks
-  } = useFormCallbacks();
-  const newCallbacks = useMemo(() => ({
-    ...formCallbacks,
-    onPathOpen: path => {
-      var _a;
-      if (!instruction && path.length === 4 && path[2] === "instructions") {
-        setParams(typed({
-          ...params,
-          [instructionParam]: (_a = path[3]) == null ? void 0 : _a._key
-        }));
-        onPathOpen([]);
-      } else {
-        setTimeout(() => onPathOpen(path), 0);
-      }
-    }
-  }), [formCallbacks, onPathOpen, params, setParams, instruction]);
-  useEffect(() => {
-    if (activePath && !instruction) {
-      onPathOpen([]);
-    }
-  }, [activePath, instruction, onPathOpen]);
-  return /* @__PURE__ */jsx(SelectedFieldContextProvider, {
-    value: context,
-    children: /* @__PURE__ */jsxs(Stack, {
-      space: 5,
-      children: [/* @__PURE__ */jsx(FieldsInitializer, {
-        pathKey,
-        activePath,
-        fieldExists,
-        onChange
-      }, pathKey), instruction && /* @__PURE__ */jsx(BackToInstructionListLink, {}), activePath && /* @__PURE__ */jsx(FormCallbacksProvider, {
-        ...newCallbacks,
-        children: /* @__PURE__ */jsx("div", {
-          style: {
-            lineHeight: "1.25em"
-          },
-          children: /* @__PURE__ */jsx(FormInput, {
-            ...props,
-            absolutePath: activePath
-          })
-        })
-      }), !activePath && props.renderDefault(props)]
+var __template$1 = (cooked, raw) => __freeze$1(__defProp$1(cooked, "raw", {
+  value: __freeze$1(raw || cooked.slice())
+}));
+var _a$1;
+const WrapPreCard = styled(Card)(_a$1 || (_a$1 = __template$1(["\n  & pre {\n    white-space: pre-wrap !important;\n  }\n"])));
+function SafeValueInput(props) {
+  return /* @__PURE__ */jsx(ErrorWrapper, {
+    onChange: props.onChange,
+    children: /* @__PURE__ */jsx(PteValueFixer, {
+      ...props
     })
   });
 }
-function useSelectedSchema(fieldPath, documentSchema) {
-  return useMemo(() => {
-    if (!fieldPath) {
-      return void 0;
-    }
-    if (fieldPath === documentRootKey) {
-      return documentSchema;
-    }
-    const path = stringToPath(fieldPath);
-    let currentSchema = documentSchema;
-    for (let i = 0; i < path.length; i++) {
-      const segment = path[i];
-      const field = currentSchema == null ? void 0 : currentSchema.fields.find(f => f.name === segment);
-      if (!field) {
-        return void 0;
-      }
-      if (i === path.length - 1) {
-        return field.type;
-      }
-      if (field.type.jsonType !== "object") {
-        return void 0;
-      }
-      currentSchema = field.type;
-    }
-    return currentSchema;
-  }, [documentSchema, fieldPath]);
+function ErrorWrapper(props) {
+  const {
+    onChange
+  } = props;
+  const [error, setError] = useState();
+  const catchError = useCallback(params => {
+    setError(params.error);
+  }, [setError]);
+  const unsetValue = useCallback(() => onChange(PatchEvent.from(unset())), [onChange]);
+  const dismiss = useCallback(() => setError(void 0), []);
+  const catcher = /* @__PURE__ */jsx(ErrorBoundary, {
+    onCatch: catchError,
+    children: props.children
+  });
+  return error ? /* @__PURE__ */jsx(Card, {
+    border: true,
+    tone: "critical",
+    padding: 2,
+    contentEditable: false,
+    children: /* @__PURE__ */jsxs(Stack$1, {
+      space: 3,
+      children: [/* @__PURE__ */jsx(Text, {
+        muted: true,
+        weight: "semibold",
+        children: "An error occurred."
+      }), /* @__PURE__ */jsx(WrapPreCard, {
+        flex: 1,
+        padding: 2,
+        tone: "critical",
+        border: true,
+        children: catcher
+      }), /* @__PURE__ */jsxs(Flex, {
+        width: "fill",
+        flex: 1,
+        gap: 3,
+        children: [/* @__PURE__ */jsx(Box, {
+          flex: 1,
+          children: /* @__PURE__ */jsx(Button, {
+            text: "Dismiss",
+            onClick: dismiss,
+            tone: "primary"
+          })
+        }), /* @__PURE__ */jsx(Button, {
+          text: "Unset value",
+          onClick: unsetValue,
+          tone: "critical"
+        })]
+      })]
+    })
+  }) : catcher;
 }
-function FieldsInitializer(_ref9) {
-  let {
-    pathKey,
-    activePath,
-    fieldExists,
+function PteValueFixer(props) {
+  const isPortableText = useMemo(() => isArraySchemaType(props.schemaType) && isPortableTextArray(props.schemaType), [props.schemaType]);
+  const value = props.value;
+  if (isPortableText && value && !value.length) {
+    return props.renderDefault({
+      ...props,
+      value: void 0
+    });
+  }
+  return props.renderDefault(props);
+}
+function AssistFormBlock(props) {
+  const presence = useAssistPresence(props.path, true);
+  const {
     onChange
-  } = _ref9;
-  const initialized = useRef(false);
-  useEffect(() => {
-    if (initialized.current || fieldExists || activePath || !pathKey) {
+  } = useFormCallbacks();
+  const key = props.value._key;
+  const localOnChange = useCallback(patchEvent => {
+    if (!key) {
       return;
     }
-    onChange([setIfMissing([], ["fields"]), insert([typed({
-      _key: pathKey,
-      _type: assistFieldTypeName,
-      path: pathKey
-    })], "after", ["fields", -1])]);
-    initialized.current = true;
-  }, [activePath, onChange, pathKey, fieldExists]);
-  return null;
+    onChange(PatchEvent.from(patchEvent).prefixAll({
+      _key: key
+    }));
+  }, [onChange, key]);
+  return /* @__PURE__ */jsx(ErrorWrapper, {
+    onChange: localOnChange,
+    children: /* @__PURE__ */jsxs(Flex, {
+      align: "center",
+      justify: "space-between",
+      children: [/* @__PURE__ */jsx(Box, {
+        flex: 1,
+        children: props.renderDefault(props)
+      }), presence.map(pre => /* @__PURE__ */jsx(AiFieldPresence, {
+        presence: pre
+      }, pre.lastActiveAt))]
+    })
+  });
+}
+function AssistItem(props) {
+  const {
+    path
+  } = props;
+  const presence = useAssistPresence(path, true);
+  return /* @__PURE__ */jsxs(Flex, {
+    align: "center",
+    width: "fill",
+    style: {
+      position: "relative"
+    },
+    children: [/* @__PURE__ */jsx(Box, {
+      flex: 1,
+      children: props.renderDefault({
+        ...props
+      })
+    }), presence.map(pre => /* @__PURE__ */jsx(Box, {
+      style: {
+        position: "absolute",
+        right: 35
+      },
+      children: /* @__PURE__ */jsx(AiFieldPresence, {
+        presence: pre
+      })
+    }, pre.user.id))]
+  });
 }
 function findFieldMember(members, fieldName) {
   return members.find(m => m.kind === "field" && m.name === fieldName || m.kind === "error" && m.fieldName === fieldName);
@@ -3143,7 +6831,7 @@ function findFieldsetMember(members, fieldsetName) {
   return members.find(m => m.kind === "fieldSet" && m.fieldSet.name === fieldsetName);
 }
 function InstructionInput(props) {
-  return /* @__PURE__ */jsxs(Stack, {
+  return /* @__PURE__ */jsxs(Stack$1, {
     space: [4, 4, 4, 5],
     children: [/* @__PURE__ */jsx(NameField, {
       ...props
@@ -3188,9 +6876,9 @@ function NameField(props) {
       }
     };
   }, [titleMember, titlePlaceholder]);
-  return /* @__PURE__ */jsx(Stack, {
+  return /* @__PURE__ */jsx(Stack$1, {
     space: 5,
-    children: /* @__PURE__ */jsxs(Stack, {
+    children: /* @__PURE__ */jsxs(Stack$1, {
       space: 2,
       children: [/* @__PURE__ */jsx(Flex, {
         gap: 1,
@@ -3343,117 +7031,10 @@ function getIcon(iconName) {
     return key === iconName;
   })) == null ? void 0 : _a[1]) != null ? _b : icons.sparkles;
 }
-function FieldAutocomplete(props) {
-  const {
-    id,
-    schemaType,
-    fieldPath,
-    onSelect,
-    includeDocument
-  } = props;
-  const fieldNames = useMemo(() => {
-    if (includeDocument) {
-      return getFieldRefsWithDocument(schemaType);
-    }
-    return getFieldRefs(schemaType);
-  }, [schemaType, includeDocument]);
-  const currentField = useMemo(() => fieldNames.find(f => f.key === fieldPath), [fieldPath, fieldNames]);
-  const autocompleteOptions = useMemo(() => fieldNames.map(field => ({
-    value: field.key,
-    field
-  })), [fieldNames]);
-  const renderOption = useCallback(option => {
-    const {
-      value,
-      field
-    } = option;
-    if (!value) {
-      return /* @__PURE__ */jsx(Card, {
-        as: "button",
-        padding: 3,
-        radius: 1,
-        children: /* @__PURE__ */jsx(Text, {
-          accent: true,
-          size: 1,
-          children: option.value
-        })
-      });
-    }
-    if (isType(field.schemaType, "document")) {
-      return /* @__PURE__ */jsx(Card, {
-        as: "button",
-        padding: 3,
-        radius: 1,
-        children: /* @__PURE__ */jsx(Text, {
-          size: 1,
-          weight: "semibold",
-          children: "The entire document"
-        })
-      });
-    }
-    const splitTitle = field.title.split("/");
-    return /* @__PURE__ */jsx(Card, {
-      as: "button",
-      padding: 3,
-      radius: 1,
-      children: /* @__PURE__ */jsxs(Flex, {
-        gap: 3,
-        children: [/* @__PURE__ */jsx(Text, {
-          size: 1,
-          children: createElement(field.icon)
-        }), /* @__PURE__ */jsx(Box, {
-          flex: "none",
-          children: /* @__PURE__ */jsxs(Breadcrumbs, {
-            separator: /* @__PURE__ */jsx(Text, {
-              muted: true,
-              size: 1,
-              children: "/"
-            }),
-            space: 1,
-            children: [splitTitle.slice(0, splitTitle.length - 1).map((pt, i) =>
-            // eslint-disable-next-line react/no-array-index-key
-            /* @__PURE__ */
-            jsx(Text, {
-              muted: true,
-              size: 1,
-              children: pt.trim()
-            }, i)), /* @__PURE__ */jsx(Text, {
-              size: 1,
-              weight: "medium",
-              children: splitTitle[splitTitle.length - 1]
-            })]
-          })
-        })]
-      })
-    });
-  }, []);
-  const renderValue = useCallback((value, option) => {
-    var _a;
-    return (_a = option == null ? void 0 : option.field.title) != null ? _a : value;
-  }, []);
-  const filterOption = useCallback((query, option) => {
-    var _a, _b, _c;
-    const lQuery = query.toLowerCase();
-    return ((_a = option == null ? void 0 : option.value) == null ? void 0 : _a.toLowerCase().includes(lQuery)) || ((_c = (_b = option == null ? void 0 : option.field) == null ? void 0 : _b.title) == null ? void 0 : _c.toLowerCase().includes(lQuery));
-  }, []);
-  return /* @__PURE__ */jsx(Autocomplete, {
-    fontSize: 1,
-    icon: currentField ? currentField.icon : SearchIcon,
-    onChange: onSelect,
-    openButton: true,
-    id,
-    options: autocompleteOptions,
-    placeholder: "Search for a field",
-    radius: 2,
-    renderOption,
-    renderValue,
-    value: currentField == null ? void 0 : currentField.key,
-    filterOption
-  });
-}
 function FieldRefPathInput(props) {
   var _a;
   const documentSchema = (_a = useContext(SelectedFieldContext)) == null ? void 0 : _a.documentSchema;
+  const typePath = useContext(TypePathContext);
   const ref = useRef(null);
   const id = useId();
   const {
@@ -3464,20 +7045,29 @@ function FieldRefPathInput(props) {
     (_b = (_a2 = ref.current) == null ? void 0 : _a2.querySelector("input")) == null ? void 0 : _b.focus();
   }, []);
   const onSelect = useCallback(path => onChange(set(path)), [onChange]);
+  const filter = useCallback(field => {
+    if (!field.key.includes("|") || !typePath) {
+      return true;
+    }
+    const dotSplit = typePath.split(".");
+    const base = dotSplit.slice(0, dotSplit.length - 1).join(".");
+    return field.key.includes(base);
+  }, [typePath]);
   if (!documentSchema) {
     return props.renderDefault(props);
   }
   return /* @__PURE__ */jsx(Box, {
     flex: 1,
     style: {
-      minWidth: 200
+      minWidth: 300
     },
     ref,
     children: /* @__PURE__ */jsx(FieldAutocomplete, {
       id,
       schemaType: documentSchema,
       onSelect,
-      fieldPath: props.value
+      fieldPath: props.value,
+      filter
     })
   });
 }
@@ -3680,7 +7270,7 @@ function useOnlyInlineBlocks(props) {
 function InstructionsArrayField(props) {
   return props.renderDefault({
     ...props,
-    title: void 0
+    title: " "
   });
 }
 const fieldReference = defineType({
@@ -3901,7 +7491,7 @@ const instruction = defineType({
             size: 1,
             children: createElement(props.icon)
           })
-        }), /* @__PURE__ */jsx(Stack, {
+        }), /* @__PURE__ */jsx(Stack$1, {
           flex: 1,
           space: 2,
           children: /* @__PURE__ */jsx(Text, {
@@ -4020,7 +7610,7 @@ const fieldInstructions = defineType({
 });
 const assistDocumentSchema = defineType({
   //NOTE: this is a document type. Using object here ensures it does not appear in structure menus
-  type: "object",
+  type: "document",
   //workaround for using object and not document
   ...{
     liveEdit: true
@@ -4100,7 +7690,7 @@ const documentInstructionStatus = defineType({
 });
 const schemaTypes = [fieldInstructions, assistDocumentSchema, prompt, fieldReference, instruction, documentInstructionStatus, instructionTask, contextDocumentSchema, userInput, promptContext];
 function useAssistSupported(path, schemaType) {
-  return useMemo(() => path.every(p => typeof p === "string") && isAssistSupported(schemaType), [path, schemaType]);
+  return useMemo(() => isAssistSupported(schemaType), [schemaType]);
 }
 function useAssistDocumentContextValue(documentId, documentSchemaType) {
   const {
@@ -4271,7 +7861,6 @@ const assistFieldActions = {
     const {
       schemaType
     } = props;
-    const assistSupported = useAssistSupported(props.path, schemaType);
     const isDocumentLevel = props.path.length === 0;
     const {
       assistDocument,
@@ -4292,9 +7881,13 @@ const assistFieldActions = {
     useAssistDocumentContextValue(props.documentId, schemaType) :
     // eslint-disable-next-line react-hooks/rules-of-hooks
     useAssistDocumentContext();
+    const {
+      value: docValue
+    } = useDocumentPane();
     const currentUser = useCurrentUser();
     const isHidden = !assistDocument;
     const pathKey = usePathKey(props.path);
+    const typePath = useTypePath(docValue, pathKey);
     const assistDocumentId = assistDocument == null ? void 0 : assistDocument._id;
     const assistableDocId = getAssistableDocId(documentSchemaType, documentId);
     const {
@@ -4303,10 +7896,12 @@ const assistFieldActions = {
       documentOnChange,
       isDocAssistable: documentIsAssistable != null ? documentIsAssistable : false
     });
+    const isSelectable = !!useSelectedField(documentSchemaType, typePath);
+    const assistSupported = useAssistSupported(props.path, schemaType) && isSelectable;
     const fieldAssist = useMemo(() => {
       var _a;
-      return ((_a = assistDocument == null ? void 0 : assistDocument.fields) != null ? _a : []).find(f => f.path == pathKey);
-    }, [assistDocument == null ? void 0 : assistDocument.fields, pathKey]);
+      return ((_a = assistDocument == null ? void 0 : assistDocument.fields) != null ? _a : []).find(f => f.path === typePath || pathKey === documentRootKey && f.path === pathKey);
+    }, [assistDocument == null ? void 0 : assistDocument.fields, pathKey, typePath]);
     const fieldAssistKey = fieldAssist == null ? void 0 : fieldAssist._key;
     const isInspectorOpen = (inspector == null ? void 0 : inspector.name) === aiInspectorId;
     const isPathSelected = pathKey === selectedPath;
@@ -4324,9 +7919,10 @@ const assistFieldActions = {
         documentId: assistableDocId,
         assistDocumentId,
         path: pathKey,
+        typePath,
         instruction
       });
-    }, [requestRunInstruction, assistableDocId, pathKey, assistDocumentId, fieldAssistKey]);
+    }, [requestRunInstruction, assistableDocId, pathKey, typePath, assistDocumentId, fieldAssistKey]);
     const privateInstructions = useMemo(() => {
       var _a;
       return ((_a = fieldAssist == null ? void 0 : fieldAssist.instructions) == null ? void 0 : _a.filter(i => i.userId && i.userId === (currentUser == null ? void 0 : currentUser.id))) || [];