@sanity/embeddings-index-ui 1.0.0

package/dist/index.js

@@ -0,0 +1,2807 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+var sanity = require('sanity');
+var jsxRuntime = require('react/jsx-runtime');
+var ui = require('@sanity/ui');
+var icons = require('@sanity/icons');
+var require$$0 = require('react');
+var router = require('sanity/router');
+var desk = require('sanity/desk');
+function _interopDefaultCompat(e) {
+  return e && typeof e === 'object' && 'default' in e ? e : {
+    default: e
+  };
+}
+var require$$0__default = /*#__PURE__*/_interopDefaultCompat(require$$0);
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+var extendStatics = function (d, b) {
+  extendStatics = Object.setPrototypeOf || {
+    __proto__: []
+  } instanceof Array && function (d, b) {
+    d.__proto__ = b;
+  } || function (d, b) {
+    for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __generator(thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function () {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator,
+    m = s && o[s],
+    i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function () {
+      if (o && i >= o.length) o = void 0;
+      return {
+        value: o && o[i++],
+        done: !o
+      };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+    r,
+    ar = [],
+    e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+}
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []),
+    i,
+    q = [];
+  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
+    return this;
+  }, i;
+  function verb(n) {
+    if (g[n]) i[n] = function (v) {
+      return new Promise(function (a, b) {
+        q.push([n, v, a, b]) > 1 || resume(n, v);
+      });
+    };
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator],
+    i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function (v) {
+      return new Promise(function (resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function (v) {
+      resolve({
+        value: v,
+        done: d
+      });
+    }, reject);
+  }
+}
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+function isFunction(value) {
+  return typeof value === 'function';
+}
+function createErrorClass(createImpl) {
+  var _super = function (instance) {
+    Error.call(instance);
+    instance.stack = new Error().stack;
+  };
+  var ctorFunc = createImpl(_super);
+  ctorFunc.prototype = Object.create(Error.prototype);
+  ctorFunc.prototype.constructor = ctorFunc;
+  return ctorFunc;
+}
+var UnsubscriptionError = createErrorClass(function (_super) {
+  return function UnsubscriptionErrorImpl(errors) {
+    _super(this);
+    this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) {
+      return i + 1 + ") " + err.toString();
+    }).join('\n  ') : '';
+    this.name = 'UnsubscriptionError';
+    this.errors = errors;
+  };
+});
+function arrRemove(arr, item) {
+  if (arr) {
+    var index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
+  }
+}
+var Subscription = function () {
+  function Subscription(initialTeardown) {
+    this.initialTeardown = initialTeardown;
+    this.closed = false;
+    this._parentage = null;
+    this._finalizers = null;
+  }
+  Subscription.prototype.unsubscribe = function () {
+    var e_1, _a, e_2, _b;
+    var errors;
+    if (!this.closed) {
+      this.closed = true;
+      var _parentage = this._parentage;
+      if (_parentage) {
+        this._parentage = null;
+        if (Array.isArray(_parentage)) {
+          try {
+            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+              var parent_1 = _parentage_1_1.value;
+              parent_1.remove(this);
+            }
+          } catch (e_1_1) {
+            e_1 = {
+              error: e_1_1
+            };
+          } finally {
+            try {
+              if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+        } else {
+          _parentage.remove(this);
+        }
+      }
+      var initialFinalizer = this.initialTeardown;
+      if (isFunction(initialFinalizer)) {
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = e instanceof UnsubscriptionError ? e.errors : [e];
+        }
+      }
+      var _finalizers = this._finalizers;
+      if (_finalizers) {
+        this._finalizers = null;
+        try {
+          for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+            var finalizer = _finalizers_1_1.value;
+            try {
+              execFinalizer(finalizer);
+            } catch (err) {
+              errors = errors !== null && errors !== void 0 ? errors : [];
+              if (err instanceof UnsubscriptionError) {
+                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+              } else {
+                errors.push(err);
+              }
+            }
+          }
+        } catch (e_2_1) {
+          e_2 = {
+            error: e_2_1
+          };
+        } finally {
+          try {
+            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+          } finally {
+            if (e_2) throw e_2.error;
+          }
+        }
+      }
+      if (errors) {
+        throw new UnsubscriptionError(errors);
+      }
+    }
+  };
+  Subscription.prototype.add = function (teardown) {
+    var _a;
+    if (teardown && teardown !== this) {
+      if (this.closed) {
+        execFinalizer(teardown);
+      } else {
+        if (teardown instanceof Subscription) {
+          if (teardown.closed || teardown._hasParent(this)) {
+            return;
+          }
+          teardown._addParent(this);
+        }
+        (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+      }
+    }
+  };
+  Subscription.prototype._hasParent = function (parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  };
+  Subscription.prototype._addParent = function (parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+  };
+  Subscription.prototype._removeParent = function (parent) {
+    var _parentage = this._parentage;
+    if (_parentage === parent) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent);
+    }
+  };
+  Subscription.prototype.remove = function (teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown);
+    if (teardown instanceof Subscription) {
+      teardown._removeParent(this);
+    }
+  };
+  Subscription.EMPTY = function () {
+    var empty = new Subscription();
+    empty.closed = true;
+    return empty;
+  }();
+  return Subscription;
+}();
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+  return value instanceof Subscription || value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+}
+function execFinalizer(finalizer) {
+  if (isFunction(finalizer)) {
+    finalizer();
+  } else {
+    finalizer.unsubscribe();
+  }
+}
+var config = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: undefined,
+  useDeprecatedSynchronousErrorHandling: false,
+  useDeprecatedNextContext: false
+};
+var timeoutProvider = {
+  setTimeout: function (handler, timeout) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+  },
+  clearTimeout: function (handle) {
+    return clearTimeout(handle);
+  },
+  delegate: undefined
+};
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function () {
+    {
+      throw err;
+    }
+  });
+}
+function noop() {}
+function errorContext(cb) {
+  {
+    cb();
+  }
+}
+var Subscriber = function (_super) {
+  __extends(Subscriber, _super);
+  function Subscriber(destination) {
+    var _this = _super.call(this) || this;
+    _this.isStopped = false;
+    if (destination) {
+      _this.destination = destination;
+      if (isSubscription(destination)) {
+        destination.add(_this);
+      }
+    } else {
+      _this.destination = EMPTY_OBSERVER;
+    }
+    return _this;
+  }
+  Subscriber.create = function (next, error, complete) {
+    return new SafeSubscriber(next, error, complete);
+  };
+  Subscriber.prototype.next = function (value) {
+    if (this.isStopped) ;else {
+      this._next(value);
+    }
+  };
+  Subscriber.prototype.error = function (err) {
+    if (this.isStopped) ;else {
+      this.isStopped = true;
+      this._error(err);
+    }
+  };
+  Subscriber.prototype.complete = function () {
+    if (this.isStopped) ;else {
+      this.isStopped = true;
+      this._complete();
+    }
+  };
+  Subscriber.prototype.unsubscribe = function () {
+    if (!this.closed) {
+      this.isStopped = true;
+      _super.prototype.unsubscribe.call(this);
+      this.destination = null;
+    }
+  };
+  Subscriber.prototype._next = function (value) {
+    this.destination.next(value);
+  };
+  Subscriber.prototype._error = function (err) {
+    try {
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  Subscriber.prototype._complete = function () {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  return Subscriber;
+}(Subscription);
+var _bind = Function.prototype.bind;
+function bind(fn, thisArg) {
+  return _bind.call(fn, thisArg);
+}
+var ConsumerObserver = function () {
+  function ConsumerObserver(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  ConsumerObserver.prototype.next = function (value) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.next) {
+      try {
+        partialObserver.next(value);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  ConsumerObserver.prototype.error = function (err) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.error) {
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    } else {
+      handleUnhandledError(err);
+    }
+  };
+  ConsumerObserver.prototype.complete = function () {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  return ConsumerObserver;
+}();
+var SafeSubscriber = function (_super) {
+  __extends(SafeSubscriber, _super);
+  function SafeSubscriber(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this;
+    var partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext) {
+      partialObserver = {
+        next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined,
+        error: error !== null && error !== void 0 ? error : undefined,
+        complete: complete !== null && complete !== void 0 ? complete : undefined
+      };
+    } else {
+      var context_1;
+      if (_this && config.useDeprecatedNextContext) {
+        context_1 = Object.create(observerOrNext);
+        context_1.unsubscribe = function () {
+          return _this.unsubscribe();
+        };
+        partialObserver = {
+          next: observerOrNext.next && bind(observerOrNext.next, context_1),
+          error: observerOrNext.error && bind(observerOrNext.error, context_1),
+          complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
+        };
+      } else {
+        partialObserver = observerOrNext;
+      }
+    }
+    _this.destination = new ConsumerObserver(partialObserver);
+    return _this;
+  }
+  return SafeSubscriber;
+}(Subscriber);
+function handleUnhandledError(error) {
+  {
+    reportUnhandledError(error);
+  }
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+var EMPTY_OBSERVER = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+var observable = function () {
+  return typeof Symbol === 'function' && Symbol.observable || '@@observable';
+}();
+function identity(x) {
+  return x;
+}
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+  return function piped(input) {
+    return fns.reduce(function (prev, fn) {
+      return fn(prev);
+    }, input);
+  };
+}
+var Observable = function () {
+  function Observable(subscribe) {
+    if (subscribe) {
+      this._subscribe = subscribe;
+    }
+  }
+  Observable.prototype.lift = function (operator) {
+    var observable = new Observable();
+    observable.source = this;
+    observable.operator = operator;
+    return observable;
+  };
+  Observable.prototype.subscribe = function (observerOrNext, error, complete) {
+    var _this = this;
+    var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+    errorContext(function () {
+      var _a = _this,
+        operator = _a.operator,
+        source = _a.source;
+      subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+    });
+    return subscriber;
+  };
+  Observable.prototype._trySubscribe = function (sink) {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      sink.error(err);
+    }
+  };
+  Observable.prototype.forEach = function (next, promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function (resolve, reject) {
+      var subscriber = new SafeSubscriber({
+        next: function (value) {
+          try {
+            next(value);
+          } catch (err) {
+            reject(err);
+            subscriber.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve
+      });
+      _this.subscribe(subscriber);
+    });
+  };
+  Observable.prototype._subscribe = function (subscriber) {
+    var _a;
+    return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+  };
+  Observable.prototype[observable] = function () {
+    return this;
+  };
+  Observable.prototype.pipe = function () {
+    var operations = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      operations[_i] = arguments[_i];
+    }
+    return pipeFromArray(operations)(this);
+  };
+  Observable.prototype.toPromise = function (promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function (resolve, reject) {
+      var value;
+      _this.subscribe(function (x) {
+        return value = x;
+      }, function (err) {
+        return reject(err);
+      }, function () {
+        return resolve(value);
+      });
+    });
+  };
+  Observable.create = function (subscribe) {
+    return new Observable(subscribe);
+  };
+  return Observable;
+}();
+function getPromiseCtor(promiseCtor) {
+  var _a;
+  return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+}
+function isObserver(value) {
+  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+function isSubscriber(value) {
+  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+}
+function hasLift(source) {
+  return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+}
+function operate(init) {
+  return function (source) {
+    if (hasLift(source)) {
+      return source.lift(function (liftedSource) {
+        try {
+          return init(liftedSource, this);
+        } catch (err) {
+          this.error(err);
+        }
+      });
+    }
+    throw new TypeError('Unable to lift unknown Observable type');
+  };
+}
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+  return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = function (_super) {
+  __extends(OperatorSubscriber, _super);
+  function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+    var _this = _super.call(this, destination) || this;
+    _this.onFinalize = onFinalize;
+    _this.shouldUnsubscribe = shouldUnsubscribe;
+    _this._next = onNext ? function (value) {
+      try {
+        onNext(value);
+      } catch (err) {
+        destination.error(err);
+      }
+    } : _super.prototype._next;
+    _this._error = onError ? function (err) {
+      try {
+        onError(err);
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._error;
+    _this._complete = onComplete ? function () {
+      try {
+        onComplete();
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._complete;
+    return _this;
+  }
+  OperatorSubscriber.prototype.unsubscribe = function () {
+    var _a;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var closed_1 = this.closed;
+      _super.prototype.unsubscribe.call(this);
+      !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+    }
+  };
+  return OperatorSubscriber;
+}(Subscriber);
+var ObjectUnsubscribedError = createErrorClass(function (_super) {
+  return function ObjectUnsubscribedErrorImpl() {
+    _super(this);
+    this.name = 'ObjectUnsubscribedError';
+    this.message = 'object unsubscribed';
+  };
+});
+var Subject = function (_super) {
+  __extends(Subject, _super);
+  function Subject() {
+    var _this = _super.call(this) || this;
+    _this.closed = false;
+    _this.currentObservers = null;
+    _this.observers = [];
+    _this.isStopped = false;
+    _this.hasError = false;
+    _this.thrownError = null;
+    return _this;
+  }
+  Subject.prototype.lift = function (operator) {
+    var subject = new AnonymousSubject(this, this);
+    subject.operator = operator;
+    return subject;
+  };
+  Subject.prototype._throwIfClosed = function () {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    }
+  };
+  Subject.prototype.next = function (value) {
+    var _this = this;
+    errorContext(function () {
+      var e_1, _a;
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        if (!_this.currentObservers) {
+          _this.currentObservers = Array.from(_this.observers);
+        }
+        try {
+          for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var observer = _c.value;
+            observer.next(value);
+          }
+        } catch (e_1_1) {
+          e_1 = {
+            error: e_1_1
+          };
+        } finally {
+          try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+          } finally {
+            if (e_1) throw e_1.error;
+          }
+        }
+      }
+    });
+  };
+  Subject.prototype.error = function (err) {
+    var _this = this;
+    errorContext(function () {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.hasError = _this.isStopped = true;
+        _this.thrownError = err;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().error(err);
+        }
+      }
+    });
+  };
+  Subject.prototype.complete = function () {
+    var _this = this;
+    errorContext(function () {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.isStopped = true;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().complete();
+        }
+      }
+    });
+  };
+  Subject.prototype.unsubscribe = function () {
+    this.isStopped = this.closed = true;
+    this.observers = this.currentObservers = null;
+  };
+  Object.defineProperty(Subject.prototype, "observed", {
+    get: function () {
+      var _a;
+      return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Subject.prototype._trySubscribe = function (subscriber) {
+    this._throwIfClosed();
+    return _super.prototype._trySubscribe.call(this, subscriber);
+  };
+  Subject.prototype._subscribe = function (subscriber) {
+    this._throwIfClosed();
+    this._checkFinalizedStatuses(subscriber);
+    return this._innerSubscribe(subscriber);
+  };
+  Subject.prototype._innerSubscribe = function (subscriber) {
+    var _this = this;
+    var _a = this,
+      hasError = _a.hasError,
+      isStopped = _a.isStopped,
+      observers = _a.observers;
+    if (hasError || isStopped) {
+      return EMPTY_SUBSCRIPTION;
+    }
+    this.currentObservers = null;
+    observers.push(subscriber);
+    return new Subscription(function () {
+      _this.currentObservers = null;
+      arrRemove(observers, subscriber);
+    });
+  };
+  Subject.prototype._checkFinalizedStatuses = function (subscriber) {
+    var _a = this,
+      hasError = _a.hasError,
+      thrownError = _a.thrownError,
+      isStopped = _a.isStopped;
+    if (hasError) {
+      subscriber.error(thrownError);
+    } else if (isStopped) {
+      subscriber.complete();
+    }
+  };
+  Subject.prototype.asObservable = function () {
+    var observable = new Observable();
+    observable.source = this;
+    return observable;
+  };
+  Subject.create = function (destination, source) {
+    return new AnonymousSubject(destination, source);
+  };
+  return Subject;
+}(Observable);
+var AnonymousSubject = function (_super) {
+  __extends(AnonymousSubject, _super);
+  function AnonymousSubject(destination, source) {
+    var _this = _super.call(this) || this;
+    _this.destination = destination;
+    _this.source = source;
+    return _this;
+  }
+  AnonymousSubject.prototype.next = function (value) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+  };
+  AnonymousSubject.prototype.error = function (err) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+  };
+  AnonymousSubject.prototype.complete = function () {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+  };
+  AnonymousSubject.prototype._subscribe = function (subscriber) {
+    var _a, _b;
+    return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+  };
+  return AnonymousSubject;
+}(Subject);
+var dateTimestampProvider = {
+  now: function () {
+    return (dateTimestampProvider.delegate || Date).now();
+  },
+  delegate: undefined
+};
+var ReplaySubject = function (_super) {
+  __extends(ReplaySubject, _super);
+  function ReplaySubject(_bufferSize, _windowTime, _timestampProvider) {
+    if (_bufferSize === void 0) {
+      _bufferSize = Infinity;
+    }
+    if (_windowTime === void 0) {
+      _windowTime = Infinity;
+    }
+    if (_timestampProvider === void 0) {
+      _timestampProvider = dateTimestampProvider;
+    }
+    var _this = _super.call(this) || this;
+    _this._bufferSize = _bufferSize;
+    _this._windowTime = _windowTime;
+    _this._timestampProvider = _timestampProvider;
+    _this._buffer = [];
+    _this._infiniteTimeWindow = true;
+    _this._infiniteTimeWindow = _windowTime === Infinity;
+    _this._bufferSize = Math.max(1, _bufferSize);
+    _this._windowTime = Math.max(1, _windowTime);
+    return _this;
+  }
+  ReplaySubject.prototype.next = function (value) {
+    var _a = this,
+      isStopped = _a.isStopped,
+      _buffer = _a._buffer,
+      _infiniteTimeWindow = _a._infiniteTimeWindow,
+      _timestampProvider = _a._timestampProvider,
+      _windowTime = _a._windowTime;
+    if (!isStopped) {
+      _buffer.push(value);
+      !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
+    }
+    this._trimBuffer();
+    _super.prototype.next.call(this, value);
+  };
+  ReplaySubject.prototype._subscribe = function (subscriber) {
+    this._throwIfClosed();
+    this._trimBuffer();
+    var subscription = this._innerSubscribe(subscriber);
+    var _a = this,
+      _infiniteTimeWindow = _a._infiniteTimeWindow,
+      _buffer = _a._buffer;
+    var copy = _buffer.slice();
+    for (var i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
+      subscriber.next(copy[i]);
+    }
+    this._checkFinalizedStatuses(subscriber);
+    return subscription;
+  };
+  ReplaySubject.prototype._trimBuffer = function () {
+    var _a = this,
+      _bufferSize = _a._bufferSize,
+      _timestampProvider = _a._timestampProvider,
+      _buffer = _a._buffer,
+      _infiniteTimeWindow = _a._infiniteTimeWindow;
+    var adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
+    _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
+    if (!_infiniteTimeWindow) {
+      var now = _timestampProvider.now();
+      var last = 0;
+      for (var i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
+        last = i;
+      }
+      last && _buffer.splice(0, last + 1);
+    }
+  };
+  return ReplaySubject;
+}(Subject);
+var isArrayLike = function (x) {
+  return x && typeof x.length === 'number' && typeof x !== 'function';
+};
+function isPromise(value) {
+  return isFunction(value === null || value === void 0 ? void 0 : value.then);
+}
+function isInteropObservable(input) {
+  return isFunction(input[observable]);
+}
+function isAsyncIterable(obj) {
+  return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+}
+function createInvalidObservableTypeError(input) {
+  return new TypeError("You provided " + (input !== null && typeof input === 'object' ? 'an invalid object' : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+function getSymbolIterator() {
+  if (typeof Symbol !== 'function' || !Symbol.iterator) {
+    return '@@iterator';
+  }
+  return Symbol.iterator;
+}
+var iterator = getSymbolIterator();
+function isIterable(input) {
+  return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
+}
+function readableStreamLikeToAsyncGenerator(readableStream) {
+  return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
+    var reader, _a, value, done;
+    return __generator(this, function (_b) {
+      switch (_b.label) {
+        case 0:
+          reader = readableStream.getReader();
+          _b.label = 1;
+        case 1:
+          _b.trys.push([1,, 9, 10]);
+          _b.label = 2;
+        case 2:
+          return [4, __await(reader.read())];
+        case 3:
+          _a = _b.sent(), value = _a.value, done = _a.done;
+          if (!done) return [3, 5];
+          return [4, __await(void 0)];
+        case 4:
+          return [2, _b.sent()];
+        case 5:
+          return [4, __await(value)];
+        case 6:
+          return [4, _b.sent()];
+        case 7:
+          _b.sent();
+          return [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          reader.releaseLock();
+          return [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function isReadableStreamLike(obj) {
+  return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
+}
+function innerFrom(input) {
+  if (input instanceof Observable) {
+    return input;
+  }
+  if (input != null) {
+    if (isInteropObservable(input)) {
+      return fromInteropObservable(input);
+    }
+    if (isArrayLike(input)) {
+      return fromArrayLike(input);
+    }
+    if (isPromise(input)) {
+      return fromPromise(input);
+    }
+    if (isAsyncIterable(input)) {
+      return fromAsyncIterable(input);
+    }
+    if (isIterable(input)) {
+      return fromIterable(input);
+    }
+    if (isReadableStreamLike(input)) {
+      return fromReadableStreamLike(input);
+    }
+  }
+  throw createInvalidObservableTypeError(input);
+}
+function fromInteropObservable(obj) {
+  return new Observable(function (subscriber) {
+    var obs = obj[observable]();
+    if (isFunction(obs.subscribe)) {
+      return obs.subscribe(subscriber);
+    }
+    throw new TypeError('Provided object does not correctly implement Symbol.observable');
+  });
+}
+function fromArrayLike(array) {
+  return new Observable(function (subscriber) {
+    for (var i = 0; i < array.length && !subscriber.closed; i++) {
+      subscriber.next(array[i]);
+    }
+    subscriber.complete();
+  });
+}
+function fromPromise(promise) {
+  return new Observable(function (subscriber) {
+    promise.then(function (value) {
+      if (!subscriber.closed) {
+        subscriber.next(value);
+        subscriber.complete();
+      }
+    }, function (err) {
+      return subscriber.error(err);
+    }).then(null, reportUnhandledError);
+  });
+}
+function fromIterable(iterable) {
+  return new Observable(function (subscriber) {
+    var e_1, _a;
+    try {
+      for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
+        var value = iterable_1_1.value;
+        subscriber.next(value);
+        if (subscriber.closed) {
+          return;
+        }
+      }
+    } catch (e_1_1) {
+      e_1 = {
+        error: e_1_1
+      };
+    } finally {
+      try {
+        if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1);
+      } finally {
+        if (e_1) throw e_1.error;
+      }
+    }
+    subscriber.complete();
+  });
+}
+function fromAsyncIterable(asyncIterable) {
+  return new Observable(function (subscriber) {
+    process$1(asyncIterable, subscriber).catch(function (err) {
+      return subscriber.error(err);
+    });
+  });
+}
+function fromReadableStreamLike(readableStream) {
+  return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
+}
+function process$1(asyncIterable, subscriber) {
+  var asyncIterable_1, asyncIterable_1_1;
+  var e_2, _a;
+  return __awaiter(this, void 0, void 0, function () {
+    var value, e_2_1;
+    return __generator(this, function (_b) {
+      switch (_b.label) {
+        case 0:
+          _b.trys.push([0, 5, 6, 11]);
+          asyncIterable_1 = __asyncValues(asyncIterable);
+          _b.label = 1;
+        case 1:
+          return [4, asyncIterable_1.next()];
+        case 2:
+          if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
+          value = asyncIterable_1_1.value;
+          subscriber.next(value);
+          if (subscriber.closed) {
+            return [2];
+          }
+          _b.label = 3;
+        case 3:
+          return [3, 1];
+        case 4:
+          return [3, 11];
+        case 5:
+          e_2_1 = _b.sent();
+          e_2 = {
+            error: e_2_1
+          };
+          return [3, 11];
+        case 6:
+          _b.trys.push([6,, 9, 10]);
+          if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8];
+          return [4, _a.call(asyncIterable_1)];
+        case 7:
+          _b.sent();
+          _b.label = 8;
+        case 8:
+          return [3, 10];
+        case 9:
+          if (e_2) throw e_2.error;
+          return [7];
+        case 10:
+          return [7];
+        case 11:
+          subscriber.complete();
+          return [2];
+      }
+    });
+  });
+}
+function share(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _a = options.connector,
+    connector = _a === void 0 ? function () {
+      return new Subject();
+    } : _a,
+    _b = options.resetOnError,
+    resetOnError = _b === void 0 ? true : _b,
+    _c = options.resetOnComplete,
+    resetOnComplete = _c === void 0 ? true : _c,
+    _d = options.resetOnRefCountZero,
+    resetOnRefCountZero = _d === void 0 ? true : _d;
+  return function (wrapperSource) {
+    var connection;
+    var resetConnection;
+    var subject;
+    var refCount = 0;
+    var hasCompleted = false;
+    var hasErrored = false;
+    var cancelReset = function () {
+      resetConnection === null || resetConnection === void 0 ? void 0 : resetConnection.unsubscribe();
+      resetConnection = undefined;
+    };
+    var reset = function () {
+      cancelReset();
+      connection = subject = undefined;
+      hasCompleted = hasErrored = false;
+    };
+    var resetAndUnsubscribe = function () {
+      var conn = connection;
+      reset();
+      conn === null || conn === void 0 ? void 0 : conn.unsubscribe();
+    };
+    return operate(function (source, subscriber) {
+      refCount++;
+      if (!hasErrored && !hasCompleted) {
+        cancelReset();
+      }
+      var dest = subject = subject !== null && subject !== void 0 ? subject : connector();
+      subscriber.add(function () {
+        refCount--;
+        if (refCount === 0 && !hasErrored && !hasCompleted) {
+          resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
+        }
+      });
+      dest.subscribe(subscriber);
+      if (!connection && refCount > 0) {
+        connection = new SafeSubscriber({
+          next: function (value) {
+            return dest.next(value);
+          },
+          error: function (err) {
+            hasErrored = true;
+            cancelReset();
+            resetConnection = handleReset(reset, resetOnError, err);
+            dest.error(err);
+          },
+          complete: function () {
+            hasCompleted = true;
+            cancelReset();
+            resetConnection = handleReset(reset, resetOnComplete);
+            dest.complete();
+          }
+        });
+        innerFrom(source).subscribe(connection);
+      }
+    })(wrapperSource);
+  };
+}
+function handleReset(reset, on) {
+  var args = [];
+  for (var _i = 2; _i < arguments.length; _i++) {
+    args[_i - 2] = arguments[_i];
+  }
+  if (on === true) {
+    reset();
+    return;
+  }
+  if (on === false) {
+    return;
+  }
+  var onSubscriber = new SafeSubscriber({
+    next: function () {
+      onSubscriber.unsubscribe();
+      reset();
+    }
+  });
+  return innerFrom(on.apply(void 0, __spreadArray([], __read(args)))).subscribe(onSubscriber);
+}
+function shareReplay(configOrBufferSize, windowTime, scheduler) {
+  var _a, _b, _c;
+  var bufferSize;
+  var refCount = false;
+  if (configOrBufferSize && typeof configOrBufferSize === 'object') {
+    _a = configOrBufferSize.bufferSize, bufferSize = _a === void 0 ? Infinity : _a, _b = configOrBufferSize.windowTime, windowTime = _b === void 0 ? Infinity : _b, _c = configOrBufferSize.refCount, refCount = _c === void 0 ? false : _c, scheduler = configOrBufferSize.scheduler;
+  } else {
+    bufferSize = configOrBufferSize !== null && configOrBufferSize !== void 0 ? configOrBufferSize : Infinity;
+  }
+  return share({
+    connector: function () {
+      return new ReplaySubject(bufferSize, windowTime, scheduler);
+    },
+    resetOnError: true,
+    resetOnComplete: false,
+    resetOnRefCountZero: refCount
+  });
+}
+function tap(observerOrNext, error, complete) {
+  var tapObserver = isFunction(observerOrNext) || error || complete ? {
+    next: observerOrNext,
+    error: error,
+    complete: complete
+  } : observerOrNext;
+  return tapObserver ? operate(function (source, subscriber) {
+    var _a;
+    (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+    var isUnsub = true;
+    source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+      var _a;
+      (_a = tapObserver.next) === null || _a === void 0 ? void 0 : _a.call(tapObserver, value);
+      subscriber.next(value);
+    }, function () {
+      var _a;
+      isUnsub = false;
+      (_a = tapObserver.complete) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+      subscriber.complete();
+    }, function (err) {
+      var _a;
+      isUnsub = false;
+      (_a = tapObserver.error) === null || _a === void 0 ? void 0 : _a.call(tapObserver, err);
+      subscriber.error(err);
+    }, function () {
+      var _a, _b;
+      if (isUnsub) {
+        (_a = tapObserver.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+      }
+      (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+    }));
+  }) : identity;
+}
+var shim = {
+  exports: {}
+};
+var useSyncExternalStoreShim_production_min = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredUseSyncExternalStoreShim_production_min;
+function requireUseSyncExternalStoreShim_production_min() {
+  if (hasRequiredUseSyncExternalStoreShim_production_min) return useSyncExternalStoreShim_production_min;
+  hasRequiredUseSyncExternalStoreShim_production_min = 1;
+  var e = require$$0__default.default;
+  function h(a, b) {
+    return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b;
+  }
+  var k = "function" === typeof Object.is ? Object.is : h,
+    l = e.useState,
+    m = e.useEffect,
+    n = e.useLayoutEffect,
+    p = e.useDebugValue;
+  function q(a, b) {
+    var d = b(),
+      f = l({
+        inst: {
+          value: d,
+          getSnapshot: b
+        }
+      }),
+      c = f[0].inst,
+      g = f[1];
+    n(function () {
+      c.value = d;
+      c.getSnapshot = b;
+      r(c) && g({
+        inst: c
+      });
+    }, [a, d, b]);
+    m(function () {
+      r(c) && g({
+        inst: c
+      });
+      return a(function () {
+        r(c) && g({
+          inst: c
+        });
+      });
+    }, [a]);
+    p(d);
+    return d;
+  }
+  function r(a) {
+    var b = a.getSnapshot;
+    a = a.value;
+    try {
+      var d = b();
+      return !k(a, d);
+    } catch (f) {
+      return !0;
+    }
+  }
+  function t(a, b) {
+    return b();
+  }
+  var u = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? t : q;
+  useSyncExternalStoreShim_production_min.useSyncExternalStore = void 0 !== e.useSyncExternalStore ? e.useSyncExternalStore : u;
+  return useSyncExternalStoreShim_production_min;
+}
+var useSyncExternalStoreShim_development = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredUseSyncExternalStoreShim_development;
+function requireUseSyncExternalStoreShim_development() {
+  if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
+  hasRequiredUseSyncExternalStoreShim_development = 1;
+  if (process.env.NODE_ENV !== "production") {
+    (function () {
+      /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === 'function') {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+      }
+      var React = require$$0__default.default;
+      var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+      function error(format) {
+        {
+          {
+            for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+              args[_key2 - 1] = arguments[_key2];
+            }
+            printWarning('error', format, args);
+          }
+        }
+      }
+      function printWarning(level, format, args) {
+        // When changing this logic, you might want to also
+        // update consoleWithStackDev.www.js as well.
+        {
+          var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+          var stack = ReactDebugCurrentFrame.getStackAddendum();
+          if (stack !== '') {
+            format += '%s';
+            args = args.concat([stack]);
+          } // eslint-disable-next-line react-internal/safe-string-coercion
+
+          var argsWithFormat = args.map(function (item) {
+            return String(item);
+          }); // Careful: RN currently depends on this prefix
+
+          argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+          // breaks IE9: https://github.com/facebook/react/issues/13610
+          // eslint-disable-next-line react-internal/no-production-logging
+
+          Function.prototype.apply.call(console[level], console, argsWithFormat);
+        }
+      }
+
+      /**
+       * inlined Object.is polyfill to avoid requiring consumers ship their own
+       * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+       */
+      function is(x, y) {
+        return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+        ;
+      }
+
+      var objectIs = typeof Object.is === 'function' ? Object.is : is;
+
+      // dispatch for CommonJS interop named imports.
+
+      var useState = React.useState,
+        useEffect = React.useEffect,
+        useLayoutEffect = React.useLayoutEffect,
+        useDebugValue = React.useDebugValue;
+      var didWarnOld18Alpha = false;
+      var didWarnUncachedGetSnapshot = false; // Disclaimer: This shim breaks many of the rules of React, and only works
+      // because of a very particular set of implementation details and assumptions
+      // -- change any one of them and it will break. The most important assumption
+      // is that updates are always synchronous, because concurrent rendering is
+      // only available in versions of React that also have a built-in
+      // useSyncExternalStore API. And we only use this shim when the built-in API
+      // does not exist.
+      //
+      // Do not assume that the clever hacks used by this hook also work in general.
+      // The point of this shim is to replace the need for hacks by other libraries.
+
+      function useSyncExternalStore(subscribe, getSnapshot,
+      // Note: The shim does not use getServerSnapshot, because pre-18 versions of
+      // React do not expose a way to check if we're hydrating. So users of the shim
+      // will need to track that themselves and return the correct value
+      // from `getSnapshot`.
+      getServerSnapshot) {
+        {
+          if (!didWarnOld18Alpha) {
+            if (React.startTransition !== undefined) {
+              didWarnOld18Alpha = true;
+              error('You are using an outdated, pre-release alpha of React 18 that ' + 'does not support useSyncExternalStore. The ' + 'use-sync-external-store shim will not work correctly. Upgrade ' + 'to a newer pre-release.');
+            }
+          }
+        } // Read the current snapshot from the store on every render. Again, this
+        // breaks the rules of React, and only works here because of specific
+        // implementation details, most importantly that updates are
+        // always synchronous.
+
+        var value = getSnapshot();
+        {
+          if (!didWarnUncachedGetSnapshot) {
+            var cachedValue = getSnapshot();
+            if (!objectIs(value, cachedValue)) {
+              error('The result of getSnapshot should be cached to avoid an infinite loop');
+              didWarnUncachedGetSnapshot = true;
+            }
+          }
+        } // Because updates are synchronous, we don't queue them. Instead we force a
+        // re-render whenever the subscribed state changes by updating an some
+        // arbitrary useState hook. Then, during render, we call getSnapshot to read
+        // the current value.
+        //
+        // Because we don't actually use the state returned by the useState hook, we
+        // can save a bit of memory by storing other stuff in that slot.
+        //
+        // To implement the early bailout, we need to track some things on a mutable
+        // object. Usually, we would put that in a useRef hook, but we can stash it in
+        // our useState hook instead.
+        //
+        // To force a re-render, we call forceUpdate({inst}). That works because the
+        // new object always fails an equality check.
+
+        var _useState = useState({
+            inst: {
+              value: value,
+              getSnapshot: getSnapshot
+            }
+          }),
+          inst = _useState[0].inst,
+          forceUpdate = _useState[1]; // Track the latest getSnapshot function with a ref. This needs to be updated
+        // in the layout phase so we can access it during the tearing check that
+        // happens on subscribe.
+
+        useLayoutEffect(function () {
+          inst.value = value;
+          inst.getSnapshot = getSnapshot; // Whenever getSnapshot or subscribe changes, we need to check in the
+          // commit phase if there was an interleaved mutation. In concurrent mode
+          // this can happen all the time, but even in synchronous mode, an earlier
+          // effect may have mutated the store.
+
+          if (checkIfSnapshotChanged(inst)) {
+            // Force a re-render.
+            forceUpdate({
+              inst: inst
+            });
+          }
+        }, [subscribe, value, getSnapshot]);
+        useEffect(function () {
+          // Check for changes right before subscribing. Subsequent changes will be
+          // detected in the subscription handler.
+          if (checkIfSnapshotChanged(inst)) {
+            // Force a re-render.
+            forceUpdate({
+              inst: inst
+            });
+          }
+          var handleStoreChange = function () {
+            // TODO: Because there is no cross-renderer API for batching updates, it's
+            // up to the consumer of this library to wrap their subscription event
+            // with unstable_batchedUpdates. Should we try to detect when this isn't
+            // the case and print a warning in development?
+            // The store changed. Check if the snapshot changed since the last time we
+            // read from the store.
+            if (checkIfSnapshotChanged(inst)) {
+              // Force a re-render.
+              forceUpdate({
+                inst: inst
+              });
+            }
+          }; // Subscribe to the store and return a clean-up function.
+
+          return subscribe(handleStoreChange);
+        }, [subscribe]);
+        useDebugValue(value);
+        return value;
+      }
+      function checkIfSnapshotChanged(inst) {
+        var latestGetSnapshot = inst.getSnapshot;
+        var prevValue = inst.value;
+        try {
+          var nextValue = latestGetSnapshot();
+          return !objectIs(prevValue, nextValue);
+        } catch (error) {
+          return true;
+        }
+      }
+      function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
+        // Note: The shim does not use getServerSnapshot, because pre-18 versions of
+        // React do not expose a way to check if we're hydrating. So users of the shim
+        // will need to track that themselves and return the correct value
+        // from `getSnapshot`.
+        return getSnapshot();
+      }
+      var canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
+      var isServerEnvironment = !canUseDOM;
+      var shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
+      var useSyncExternalStore$2 = React.useSyncExternalStore !== undefined ? React.useSyncExternalStore : shim;
+      useSyncExternalStoreShim_development.useSyncExternalStore = useSyncExternalStore$2;
+      /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === 'function') {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+      }
+    })();
+  }
+  return useSyncExternalStoreShim_development;
+}
+if (process.env.NODE_ENV === 'production') {
+  shim.exports = requireUseSyncExternalStoreShim_production_min();
+} else {
+  shim.exports = requireUseSyncExternalStoreShim_development();
+}
+var shimExports = shim.exports;
+function getValue(value) {
+  return typeof value === 'function' ? value() : value;
+}
+var cache = new WeakMap();
+function getOrCreateStore(inputObservable, initialValue) {
+  if (!cache.has(inputObservable)) {
+    var entry_1 = {
+      currentValue: initialValue
+    };
+    entry_1.observable = inputObservable.pipe(shareReplay({
+      refCount: true,
+      bufferSize: 1
+    }), tap(function (value) {
+      return entry_1.currentValue = value;
+    }));
+    // Eagerly subscribe to sync set `entry.currentValue` to what the observable returns
+    entry_1.subscription = entry_1.observable.subscribe();
+    cache.set(inputObservable, entry_1);
+  }
+  return cache.get(inputObservable);
+}
+function useObservable(observable, initialValue) {
+  var _a = require$$0.useMemo(function () {
+      var store = getOrCreateStore(observable, getValue(initialValue));
+      if (store.subscription.closed) {
+        store.subscription = store.observable.subscribe();
+      }
+      return [function getSnapshot() {
+        // @TODO: perf opt opportunity: we could do `store.subscription.unsubscribe()` here to clear up some memory, as this subscription is only needed to provide a sync initialValue.
+        return store.currentValue;
+      }, function subscribe(callback) {
+        // @TODO: perf opt opportunity: we could do `store.subscription.unsubscribe()` here as we only need 1 subscription active to keep the observer alive
+        var sub = store.observable.subscribe(callback);
+        return function () {
+          sub.unsubscribe();
+        };
+      }];
+    }, [observable]),
+    getSnapshot = _a[0],
+    subscribe = _a[1];
+  var shouldRestoreSubscriptionRef = require$$0.useRef(false);
+  require$$0.useEffect(function () {
+    var store = getOrCreateStore(observable, getValue(initialValue));
+    if (shouldRestoreSubscriptionRef.current) {
+      if (store.subscription.closed) {
+        store.subscription = store.observable.subscribe();
+      }
+      shouldRestoreSubscriptionRef.current = false;
+    }
+    return function () {
+      // React StrictMode will call effects as `setup + teardown + setup` thus we can't trust this callback as "react is about to unmount"
+      // Tracking this ref lets us set the subscription back up on the next `setup` call if needed, and if it really did unmounted then all is well
+      shouldRestoreSubscriptionRef.current = !store.subscription.closed;
+      store.subscription.unsubscribe();
+    };
+  }, [observable]);
+  return shimExports.useSyncExternalStore(subscribe, getSnapshot);
+}
+function useMemoObservable(observableOrFactory, deps, initialValue) {
+  return useObservable(require$$0.useMemo(function () {
+    return getValue(observableOrFactory);
+  }, deps), initialValue);
+}
+function DocumentPreview(_ref) {
+  let {
+    documentId,
+    style,
+    ...buttonProps
+  } = _ref;
+  const client = sanity.useClient({
+    apiVersion: "2023-06-06"
+  });
+  const [type, setType] = require$$0.useState(void 0);
+  const schema = sanity.useSchema();
+  const schemaType = type ? schema.get(type) : void 0;
+  require$$0.useEffect(() => {
+    client.fetch("* [_id==$id]._type", {
+      id: documentId
+    }).then(setType);
+  }, [documentId, client]);
+  if (!type) {
+    return /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
+      style: {
+        minHeight: "36px"
+      },
+      children: /* @__PURE__ */jsxRuntime.jsx(sanity.DefaultPreview, {
+        withShadow: false,
+        withBorder: false,
+        title: "Loading...",
+        schemaType,
+        isPlaceholder: true
+      })
+    });
+  }
+  if (!schemaType) {
+    return /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
+      children: /* @__PURE__ */jsxRuntime.jsx(sanity.DefaultPreview, {
+        withShadow: false,
+        withBorder: false,
+        media: () => /* @__PURE__ */jsxRuntime.jsx(icons.ErrorOutlineIcon, {}),
+        title: /* @__PURE__ */jsxRuntime.jsxs(jsxRuntime.Fragment, {
+          children: ["Unknown type ", /* @__PURE__ */jsxRuntime.jsx("code", {
+            children: type != null ? type : "N/A"
+          }), " for ", documentId]
+        })
+      })
+    });
+  }
+  return /* @__PURE__ */jsxRuntime.jsx(DocumentPreviewInner, {
+    documentId,
+    schemaType,
+    style,
+    ...buttonProps
+  });
+}
+function DocumentPreviewInner(_ref2) {
+  let {
+    documentId,
+    schemaType,
+    style,
+    button
+  } = _ref2;
+  const documentPreviewStore = sanity.useDocumentPreviewStore();
+  const {
+    draft,
+    published,
+    isLoading
+  } = useMemoObservable(() => sanity.getPreviewStateObservable(documentPreviewStore, schemaType, documentId, ""), [documentId, documentPreviewStore, schemaType]);
+  const sanityDocument = require$$0.useMemo(() => {
+    return {
+      _id: documentId,
+      _type: schemaType == null ? void 0 : schemaType.name
+    };
+  }, [documentId, schemaType == null ? void 0 : schemaType.name]);
+  const {
+    onClick: onIntentClick,
+    href
+  } = router.useIntentLink({
+    intent: "edit",
+    params: {
+      id: documentId,
+      type: schemaType == null ? void 0 : schemaType.name
+    }
+  });
+  const preview = /* @__PURE__ */jsxRuntime.jsx(sanity.SanityDefaultPreview, {
+    ...sanity.getPreviewValueWithFallback({
+      draft,
+      published,
+      value: sanityDocument
+    }),
+    isPlaceholder: isLoading != null ? isLoading : true,
+    layout: "default",
+    icon: schemaType == null ? void 0 : schemaType.icon
+  });
+  if (button) {
+    return /* @__PURE__ */jsxRuntime.jsx(ui.Button, {
+      as: "a",
+      href,
+      onClick: onIntentClick,
+      mode: "ghost",
+      style: {
+        width: "100%",
+        ...style
+      },
+      children: preview
+    });
+  }
+  return /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+    style: {
+      width: "100%"
+    },
+    children: preview
+  });
+}
+function queryIndex(queryConfig, client) {
+  const {
+    query,
+    indexName,
+    maxResults,
+    filter
+  } = queryConfig;
+  const projectId = client.config().projectId;
+  const dataset = client.config().dataset;
+  const queryString = query == null ? void 0 : query.trim();
+  return client.request({
+    method: "POST",
+    url: "/embeddings-index/query/".concat(dataset, "/").concat(indexName, "?projectId=").concat(projectId),
+    body: {
+      query: queryString,
+      maxResults,
+      filter
+    }
+  });
+}
+function getIndexes(client) {
+  const projectId = client.config().projectId;
+  const dataset = client.config().dataset;
+  return client.request({
+    method: "GET",
+    url: "/embeddings-index/".concat(dataset, "?projectId=").concat(projectId)
+  });
+}
+function deleteIndex(indexName, client) {
+  const projectId = client.config().projectId;
+  const dataset = client.config().dataset;
+  return client.request({
+    method: "DELETE",
+    url: "/embeddings-index/".concat(dataset, "/").concat(indexName, "?projectId=").concat(projectId)
+  });
+}
+function publicId(id) {
+  return id.replace("drafts.", "");
+}
+const NO_OPTIONS = [];
+const NO_FILTER = () => true;
+function SemanticSearchReferenceInput(props) {
+  var _a, _b, _c;
+  const defaultEnabled = ((_c = (_b = (_a = props.schemaType) == null ? void 0 : _a.options) == null ? void 0 : _b.embeddingsIndex) == null ? void 0 : _c.searchMode) === "embeddings";
+  const [semantic, setSemantic] = require$$0.useState(defaultEnabled);
+  const toggleSemantic = require$$0.useCallback(() => setSemantic(current => !current), []);
+  return /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+    gap: 2,
+    flex: 1,
+    style: {
+      width: "100%"
+    },
+    children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+      flex: 1,
+      style: {
+        maxHeight: 36,
+        overflow: "hidden"
+      },
+      children: semantic ? /* @__PURE__ */jsxRuntime.jsx(SemanticSearchInput, {
+        ...props
+      }) : props.renderDefault(props)
+    }), /* @__PURE__ */jsxRuntime.jsx(ui.Button, {
+      icon: semantic ? icons.EarthGlobeIcon : icons.LinkIcon,
+      onClick: toggleSemantic,
+      mode: "bleed",
+      title: semantic ? "Switch to standard reference search" : "Switch to semantic reference search"
+    })]
+  });
+}
+function useDebouncedValue(value, ms) {
+  const [debouncedValue, setDebouncedValue] = require$$0.useState(value);
+  require$$0.useEffect(() => {
+    const timeoutId = setTimeout(() => {
+      setDebouncedValue(value);
+    }, ms);
+    return () => clearTimeout(timeoutId);
+  }, [value, ms]);
+  return debouncedValue;
+}
+function useApiClient$2() {
+  const client = sanity.useClient({
+    apiVersion: "vX"
+  });
+  return require$$0.useMemo(() => client, [client]);
+}
+function SemanticSearchInput(props) {
+  const {
+    onPathFocus,
+    onChange,
+    readOnly,
+    schemaType,
+    value
+  } = props;
+  const {
+    value: currentDocument
+  } = desk.useDocumentPane();
+  const docRef = require$$0.useRef(currentDocument);
+  const autocompleteRef = require$$0.useRef(null);
+  const id = require$$0.useId();
+  const [query, setQuery] = require$$0.useState("");
+  const queryRef = require$$0.useRef(query);
+  const debouncedQuery = useDebouncedValue(query, 300);
+  const prevDebouncedQuery = require$$0.useRef(debouncedQuery);
+  const [searching, setSearching] = require$$0.useState(false);
+  const [options, setOptions] = require$$0.useState(NO_OPTIONS);
+  const client = useApiClient$2();
+  require$$0.useEffect(() => {
+    docRef.current = currentDocument;
+  }, [currentDocument]);
+  require$$0.useEffect(() => {
+    var _a;
+    if (value == null ? void 0 : value._ref) {
+      (_a = autocompleteRef.current) == null ? void 0 : _a.focus();
+    }
+  }, []);
+  const handleFocus = require$$0.useCallback(() => onPathFocus(["_ref"]), [onPathFocus]);
+  const handleBlur = require$$0.useCallback(() => onPathFocus([]), [onPathFocus]);
+  const runIndexQuery = require$$0.useCallback(queryString => {
+    var _a, _b, _c, _d;
+    setSearching(true);
+    const refSchema = schemaType;
+    const indexName = (_b = (_a = refSchema.options) == null ? void 0 : _a.embeddingsIndex) == null ? void 0 : _b.indexName;
+    const maxResults = (_d = (_c = refSchema.options) == null ? void 0 : _c.embeddingsIndex) == null ? void 0 : _d.maxResults;
+    const typeFilter = refSchema.to.map(ref => ref.name);
+    if (!indexName) {
+      throw new Error("Reference option embeddingsIndex.indexName is required, but was missing in type ".concat(refSchema.name));
+    }
+    queryIndex({
+      query: queryString,
+      indexName,
+      maxResults,
+      filter: {
+        type: typeFilter
+      }
+    }, client).then(result => {
+      if (queryRef.current === queryString) {
+        setSearching(false);
+        setOptions(result.filter(r => r.value.documentId !== publicId(docRef.current._id)).map(r => sanity.typed({
+          result: r,
+          value: r.value.documentId
+        })));
+      }
+    }).catch(e => {
+      if (queryRef.current === queryString) {
+        setSearching(false);
+      }
+      throw e;
+    });
+  }, [client, schemaType]);
+  require$$0.useEffect(() => {
+    if (prevDebouncedQuery.current !== debouncedQuery) {
+      runIndexQuery(debouncedQuery);
+    }
+    prevDebouncedQuery.current = debouncedQuery;
+  }, [debouncedQuery, runIndexQuery]);
+  const handleChange = require$$0.useCallback(nextId => {
+    if (!nextId) {
+      onChange(sanity.unset());
+      onPathFocus([]);
+      return;
+    }
+    const patches = [sanity.setIfMissing({}), sanity.set(schemaType.name, ["_type"]), sanity.set(publicId(nextId), ["_ref"]), sanity.unset(["_weak"]), sanity.unset(["_strengthenOnPublish"])];
+    onChange(patches);
+    onPathFocus([]);
+  }, [onChange, onPathFocus, schemaType.name]);
+  const openButtonConfig = require$$0.useMemo(() => ({
+    onClick: () => runIndexQuery(queryRef.current)
+  }), [runIndexQuery, queryRef]);
+  const handleQueryChange = require$$0.useCallback(newValue => {
+    const newQuery = newValue != null ? newValue : "";
+    queryRef.current = newQuery;
+    setQuery(newQuery);
+  }, [setQuery]);
+  return /* @__PURE__ */jsxRuntime.jsx(ui.Autocomplete, {
+    id,
+    ref: autocompleteRef,
+    "data-testid": "semantic-autocomplete",
+    placeholder: "Type to search",
+    openButton: openButtonConfig,
+    onFocus: handleFocus,
+    onChange: handleChange,
+    loading: searching,
+    onBlur: handleBlur,
+    readOnly,
+    filterOption: NO_FILTER,
+    onQueryChange: handleQueryChange,
+    options,
+    renderOption: AutocompleteOption
+  });
+}
+function AutocompleteOption(props) {
+  return /* @__PURE__ */jsxRuntime.jsx(ui.Button, {
+    mode: "bleed",
+    padding: 1,
+    style: {
+      width: "100%"
+    },
+    children: /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+      gap: 2,
+      align: "center",
+      children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+        flex: 1,
+        children: /* @__PURE__ */jsxRuntime.jsx(DocumentPreview, {
+          documentId: props.result.value.documentId
+        })
+      }), /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+        padding: 2,
+        children: /* @__PURE__ */jsxRuntime.jsxs(ui.Text, {
+          size: 1,
+          muted: true,
+          title: "Relevance",
+          children: [Math.floor(props.result.score * 100), "%"]
+        })
+      })]
+    })
+  });
+}
+function isType(schemaType, typeName) {
+  if (schemaType.name === typeName) {
+    return true;
+  }
+  if (!schemaType.type) {
+    return false;
+  }
+  return isType(schemaType.type, typeName);
+}
+const embeddingsIndexReferenceInput = sanity.definePlugin({
+  name: "@sanity/embeddings-index-reference-input",
+  form: {
+    components: {
+      input: props => {
+        var _a, _b;
+        if (sanity.isObjectInputProps(props) && isType(props.schemaType, "reference") && ((_b = (_a = props.schemaType.options) == null ? void 0 : _a.embeddingsIndex) == null ? void 0 : _b.indexName)) {
+          return /* @__PURE__ */jsxRuntime.jsx(SemanticSearchReferenceInput, {
+            ...props
+          });
+        }
+        return props.renderDefault(props);
+      }
+    }
+  }
+});
+function useApiClient$1(customApiClient) {
+  const client = sanity.useClient({
+    apiVersion: "vX"
+  });
+  return require$$0.useMemo(() => customApiClient ? customApiClient(client) : client, [client, customApiClient]);
+}
+const defaultProjection = "{...}";
+function useDefaultIndex(schema, dataset) {
+  const defaultFilter = require$$0.useMemo(() => "_type in [".concat(schema.getTypeNames().map(n => schema.get(n)).filter(schemaType => Boolean(schemaType && isType(schemaType, "document"))).filter(documentType => !documentType.name.startsWith("sanity.") && !documentType.name.startsWith("assist.") && documentType.name !== "document").map(documentType => '"'.concat(documentType.name, '"')).join(",\n"), "]"), [schema]);
+  return require$$0.useMemo(() => ({
+    dataset,
+    projection: defaultProjection,
+    filter: defaultFilter
+  }), [defaultFilter, dataset]);
+}
+function IndexFormInput(props) {
+  var _a;
+  const {
+    label,
+    index,
+    prop,
+    onChange,
+    readOnly,
+    placeholder,
+    type
+  } = props;
+  const handleChange = require$$0.useCallback(propValue => onChange(current => ({
+    ...current,
+    [prop]: propValue
+  })), [onChange, prop]);
+  return /* @__PURE__ */jsxRuntime.jsx(FormInput, {
+    label,
+    onChange: handleChange,
+    value: (_a = index[prop]) != null ? _a : "",
+    readOnly,
+    placeholder,
+    type
+  });
+}
+function FormInput(props) {
+  const {
+    label,
+    onChange,
+    value,
+    readOnly,
+    placeholder,
+    type = "text"
+  } = props;
+  const id = require$$0.useId();
+  const handleChange = require$$0.useCallback(e => onChange(e.currentTarget.value), [onChange]);
+  return /* @__PURE__ */jsxRuntime.jsxs(ui.Stack, {
+    space: 3,
+    children: [/* @__PURE__ */jsxRuntime.jsx(ui.Label, {
+      muted: true,
+      htmlFor: id,
+      children: /* @__PURE__ */jsxRuntime.jsx("label", {
+        htmlFor: id,
+        children: label
+      })
+    }), type === "text" ? /* @__PURE__ */jsxRuntime.jsx(ui.TextInput, {
+      id,
+      value,
+      onChange: handleChange,
+      readOnly,
+      placeholder
+    }) : /* @__PURE__ */jsxRuntime.jsx(ui.TextArea, {
+      id,
+      value,
+      rows: 3,
+      onChange: handleChange,
+      readOnly,
+      placeholder,
+      style: {
+        resize: "vertical"
+      }
+    })]
+  });
+}
+function EditIndexDialog(props) {
+  const {
+    open,
+    onClose,
+    onSubmit
+  } = props;
+  const id = require$$0.useId();
+  const ref = require$$0.useRef(null);
+  require$$0.useEffect(() => {
+    if (!open) {
+      return;
+    }
+    setTimeout(() => {
+      var _a, _b;
+      return (_b = (_a = ref.current) == null ? void 0 : _a.querySelector("input")) == null ? void 0 : _b.focus();
+    });
+  }, [ref, open]);
+  const handleSubmit = require$$0.useCallback(index => {
+    onSubmit(index);
+    onClose();
+  }, [onSubmit, onClose]);
+  return open ? /* @__PURE__ */jsxRuntime.jsx(ui.Dialog, {
+    id,
+    width: 1,
+    ref,
+    onClose,
+    header: "Create embeddings index",
+    children: /* @__PURE__ */jsxRuntime.jsx(ui.Stack, {
+      padding: 4,
+      space: 5,
+      children: /* @__PURE__ */jsxRuntime.jsx(IndexEditor, {
+        readOnly: false,
+        onSubmit: handleSubmit
+      })
+    })
+  }) : null;
+}
+function IndexEditor(props) {
+  var _a;
+  const {
+    readOnly,
+    index: selectedIndex,
+    onSubmit
+  } = props;
+  const client = useApiClient$1();
+  const schema = sanity.useSchema();
+  const defaultIndex = useDefaultIndex(schema, (_a = client.config().dataset) != null ? _a : "");
+  const [errors, setErrors] = require$$0.useState();
+  const [loading, setLoading] = require$$0.useState();
+  const [index, setIndex] = require$$0.useState(() => ({
+    ...defaultIndex,
+    ...selectedIndex
+  }));
+  require$$0.useEffect(() => setIndex(selectedIndex != null ? selectedIndex : {
+    ...defaultIndex
+  }), [selectedIndex, defaultIndex]);
+  const handleSubmit = require$$0.useCallback(e => {
+    e.preventDefault();
+    if (readOnly) {
+      return;
+    }
+    const validationErrors = [];
+    if (!index.indexName) {
+      validationErrors.push("Index name is required");
+    } else if (!index.indexName.match(/^[a-zA-Z0-9-_]+$/g)) {
+      validationErrors.push("Index name can only contain the letters a-z, numbers - and _");
+    }
+    if (!index.dataset) {
+      validationErrors.push("Dataset is required");
+    }
+    if (!index.filter) {
+      validationErrors.push("Filter is required");
+    }
+    if (!index.projection) {
+      validationErrors.push("Projection is required");
+    }
+    if (validationErrors.length) {
+      setErrors(validationErrors);
+      return;
+    }
+    const {
+      projectId
+    } = client.config();
+    setLoading(true);
+    client.request({
+      method: "POST",
+      url: "/embeddings-index/".concat(index.dataset, "?projectId=").concat(projectId),
+      body: {
+        indexName: index.indexName,
+        projection: index.projection,
+        filter: index.filter
+      }
+    }).then(response => {
+      if (onSubmit) {
+        onSubmit(response.index);
+      }
+    }).catch(err => {
+      console.error(err);
+      setErrors([err.message]);
+    }).finally(() => {
+      setLoading(false);
+    });
+  }, [index, readOnly, onSubmit, client]);
+  return /* @__PURE__ */jsxRuntime.jsx("form", {
+    onSubmit: handleSubmit,
+    children: /* @__PURE__ */jsxRuntime.jsxs(ui.Stack, {
+      space: 4,
+      children: [(errors == null ? void 0 : errors.length) ? /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
+        tone: "critical",
+        border: true,
+        padding: 2,
+        children: /* @__PURE__ */jsxRuntime.jsx(ui.Text, {
+          children: /* @__PURE__ */jsxRuntime.jsx("ul", {
+            style: {
+              marginLeft: -10
+            },
+            children: errors == null ? void 0 : errors.map((error, i) => /* @__PURE__ */jsxRuntime.jsx("li", {
+              children: error
+            }, "".concat(error, "-").concat(i)))
+          })
+        })
+      }) : null, /* @__PURE__ */jsxRuntime.jsx(IndexFormInput, {
+        label: "Index name",
+        placeholder: "Name of index without spaces...",
+        index,
+        prop: "indexName",
+        onChange: setIndex,
+        readOnly
+      }), /* @__PURE__ */jsxRuntime.jsx(IndexFormInput, {
+        label: "Dataset",
+        index,
+        prop: "dataset",
+        onChange: setIndex,
+        readOnly: true
+      }), /* @__PURE__ */jsxRuntime.jsx(IndexFormInput, {
+        label: "Projection",
+        placeholder: defaultIndex.projection,
+        index,
+        prop: "projection",
+        onChange: setIndex,
+        readOnly,
+        type: "textarea"
+      }), /* @__PURE__ */jsxRuntime.jsx(IndexFormInput, {
+        label: "Filter",
+        placeholder: defaultIndex.filter,
+        index,
+        prop: "filter",
+        onChange: setIndex,
+        readOnly,
+        type: "textarea"
+      }), onSubmit && /* @__PURE__ */jsxRuntime.jsx(ui.Button, {
+        type: "submit",
+        text: "Create index",
+        icon: loading ? /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+          style: {
+            marginTop: 5
+          },
+          children: /* @__PURE__ */jsxRuntime.jsx(ui.Spinner, {})
+        }) : icons.AddIcon,
+        disabled: readOnly || loading,
+        tone: "primary"
+      })]
+    })
+  });
+}
+function IndexList(props) {
+  const {
+    loading,
+    selectedIndex,
+    indexes,
+    onIndexSelected
+  } = props;
+  return /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
+    tone: "default",
+    style: {
+      opacity: loading ? 0.5 : 1
+    },
+    children: /* @__PURE__ */jsxRuntime.jsxs(ui.Stack, {
+      space: 2,
+      children: [/* @__PURE__ */jsxRuntime.jsx(ui.Card, {
+        borderBottom: true,
+        flex: 1,
+        paddingBottom: 2,
+        children: /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+          children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+            flex: 1,
+            children: /* @__PURE__ */jsxRuntime.jsx(ui.Label, {
+              muted: true,
+              children: "Index name"
+            })
+          }), /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+            flex: 1,
+            children: /* @__PURE__ */jsxRuntime.jsx(ui.Label, {
+              muted: true,
+              children: "Dataset"
+            })
+          }), /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+            flex: 1,
+            children: /* @__PURE__ */jsxRuntime.jsx(ui.Label, {
+              muted: true,
+              children: "Status"
+            })
+          }), /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+            flex: 1,
+            children: /* @__PURE__ */jsxRuntime.jsx(ui.Label, {
+              muted: true,
+              children: "Progress"
+            })
+          })]
+        })
+      }), indexes.length ? /* @__PURE__ */jsxRuntime.jsx(ui.Stack, {
+        space: 2,
+        style: {
+          maxHeight: 200,
+          overflow: "auto"
+        },
+        children: indexes.map(index => /* @__PURE__ */jsxRuntime.jsx(IndexRow, {
+          selectedIndex,
+          index,
+          onIndexSelected
+        }, index.indexName))
+      }) : /* @__PURE__ */jsxRuntime.jsx(ui.Text, {
+        muted: true,
+        children: "No indexes found."
+      })]
+    })
+  });
+}
+function IndexRow(props) {
+  const {
+    selectedIndex,
+    index,
+    onIndexSelected
+  } = props;
+  const onSelect = require$$0.useCallback(() => onIndexSelected(index), [onIndexSelected, index]);
+  return /* @__PURE__ */jsxRuntime.jsx(ui.Button, {
+    tone: (selectedIndex == null ? void 0 : selectedIndex.indexName) === index.indexName ? "primary" : "default",
+    mode: (selectedIndex == null ? void 0 : selectedIndex.indexName) === index.indexName ? "default" : "bleed",
+    onClick: onSelect,
+    children: /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+      children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+        flex: 1,
+        children: index.indexName
+      }), /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+        flex: 1,
+        children: index.dataset
+      }), /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+        flex: 1,
+        children: index.status
+      }), /* @__PURE__ */jsxRuntime.jsxs(ui.Box, {
+        flex: 1,
+        children: [index.startDocumentCount ? Math.floor((index.startDocumentCount - index.remainingDocumentCount) / index.startDocumentCount * 100) : "?", "%"]
+      })]
+    })
+  }, index.indexName);
+}
+const NO_RESULTS = [];
+function QueryIndex(props) {
+  const {
+    indexName
+  } = props;
+  const [query, setQuery] = require$$0.useState("");
+  const [searching, setSearching] = require$$0.useState(false);
+  const [results, setResults] = require$$0.useState(NO_RESULTS);
+  const client = useApiClient$1();
+  const search = require$$0.useCallback(queryString => {
+    setSearching(true);
+    return queryIndex({
+      query: queryString,
+      indexName,
+      maxResults: 5
+    }, client).then(setResults).finally(() => setSearching(false));
+  }, [client, indexName]);
+  const onInputChange = require$$0.useCallback(e => {
+    setQuery(e.currentTarget.value);
+  }, []);
+  const onKeyDown = require$$0.useCallback(e => {
+    if (e.key === "Enter") {
+      search(query).catch(console.error);
+    }
+  }, [search, query]);
+  return /* @__PURE__ */jsxRuntime.jsxs(ui.Stack, {
+    space: 3,
+    flex: 1,
+    children: [/* @__PURE__ */jsxRuntime.jsx(ui.Flex, {
+      flex: 1,
+      children: /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
+        flex: 1,
+        children: /* @__PURE__ */jsxRuntime.jsx(ui.TextInput, {
+          iconRight: searching ? /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+            style: {
+              marginTop: 5
+            },
+            children: /* @__PURE__ */jsxRuntime.jsx(ui.Spinner, {})
+          }) : icons.SearchIcon,
+          placeholder: "Find documents",
+          value: query,
+          disabled: searching,
+          onChange: onInputChange,
+          onKeyDown
+        })
+      })
+    }), /* @__PURE__ */jsxRuntime.jsx(ui.Flex, {
+      gap: 4,
+      style: {
+        opacity: searching ? 0.5 : 1
+      },
+      children: /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+        flex: 1,
+        children: /* @__PURE__ */jsxRuntime.jsx(ResultList, {
+          results,
+          query
+        })
+      })
+    })]
+  });
+}
+function ResultList(props) {
+  const {
+    results,
+    query
+  } = props;
+  return /* @__PURE__ */jsxRuntime.jsx(ui.Stack, {
+    space: 4,
+    height: "fill",
+    children: /* @__PURE__ */jsxRuntime.jsxs(ui.Stack, {
+      space: 2,
+      children: [results.map(r => /* @__PURE__ */jsxRuntime.jsx(ResultEntry, {
+        result: r
+      }, r.value.documentId)), !results.length && query ? "No results." : null]
+    })
+  });
+}
+function ResultEntry(props) {
+  return /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+    gap: 4,
+    align: "center",
+    children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+      flex: 1,
+      children: /* @__PURE__ */jsxRuntime.jsx(DocumentPreview, {
+        documentId: props.result.value.documentId,
+        button: true
+      })
+    }), /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+      children: /* @__PURE__ */jsxRuntime.jsxs(ui.Text, {
+        muted: true,
+        size: 1,
+        children: [Math.floor(props.result.score * 100), " %"]
+      })
+    })]
+  });
+}
+function IndexInfo(_ref3) {
+  let {
+    selectedIndex,
+    onDeleteIndex
+  } = _ref3;
+  var _a;
+  const handleDelete = require$$0.useCallback(() => onDeleteIndex(selectedIndex), [selectedIndex, onDeleteIndex]);
+  return /* @__PURE__ */jsxRuntime.jsxs(ui.Stack, {
+    space: 4,
+    flex: 1,
+    children: [/* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+      align: "center",
+      flex: 1,
+      gap: 2,
+      children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+        flex: 1,
+        children: /* @__PURE__ */jsxRuntime.jsxs(ui.Heading, {
+          children: ["Index: ", (_a = selectedIndex == null ? void 0 : selectedIndex.indexName) != null ? _a : "Untitled"]
+        })
+      }), /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+        children: /* @__PURE__ */jsxRuntime.jsx(ui.MenuButton, {
+          button: /* @__PURE__ */jsxRuntime.jsx(ui.Button, {
+            title: "Open index actions",
+            icon: icons.EllipsisVerticalIcon,
+            padding: 2,
+            mode: "ghost"
+          }),
+          id: "button-".concat(selectedIndex.indexName),
+          menu: /* @__PURE__ */jsxRuntime.jsx(ui.Menu, {
+            children: /* @__PURE__ */jsxRuntime.jsx(ui.MenuItem, {
+              text: "Delete index",
+              icon: icons.TrashIcon,
+              tone: "critical",
+              onClick: handleDelete
+            })
+          }),
+          popover: {
+            placement: "right"
+          }
+        })
+      })]
+    }), /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+      gap: 6,
+      children: [/* @__PURE__ */jsxRuntime.jsxs(ui.Stack, {
+        space: 4,
+        flex: 1,
+        style: {
+          maxWidth: 600
+        },
+        children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+          children: /* @__PURE__ */jsxRuntime.jsx(IndexEditor, {
+            index: selectedIndex,
+            readOnly: true
+          })
+        }), /* @__PURE__ */jsxRuntime.jsx(IndexStatus, {
+          selectedIndex
+        })]
+      }), /* @__PURE__ */jsxRuntime.jsxs(ui.Stack, {
+        space: 3,
+        flex: 1,
+        children: [/* @__PURE__ */jsxRuntime.jsx(ui.Label, {
+          muted: true,
+          children: "Query index"
+        }), /* @__PURE__ */jsxRuntime.jsx(QueryIndex, {
+          indexName: selectedIndex.indexName
+        }, selectedIndex.indexName)]
+      })]
+    })]
+  });
+}
+function IndexStatus(_ref4) {
+  let {
+    selectedIndex
+  } = _ref4;
+  return /* @__PURE__ */jsxRuntime.jsxs(ui.Stack, {
+    space: 4,
+    flex: 1,
+    children: [/* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+      gap: 2,
+      align: "center",
+      children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+        flex: 1,
+        children: /* @__PURE__ */jsxRuntime.jsx(ui.Label, {
+          size: 1,
+          muted: true,
+          children: "Status"
+        })
+      }), /* @__PURE__ */jsxRuntime.jsx(ui.Stack, {
+        space: 2,
+        children: /* @__PURE__ */jsxRuntime.jsx(ui.Text, {
+          children: selectedIndex.status
+        })
+      })]
+    }), /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+      gap: 5,
+      align: "center",
+      children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+        flex: 1,
+        children: /* @__PURE__ */jsxRuntime.jsx(ui.Label, {
+          size: 1,
+          muted: true,
+          children: "Indexing progress"
+        })
+      }), /* @__PURE__ */jsxRuntime.jsx(ui.Stack, {
+        space: 2,
+        children: /* @__PURE__ */jsxRuntime.jsxs(ui.Text, {
+          children: [selectedIndex.startDocumentCount - selectedIndex.remainingDocumentCount, " /", " ", selectedIndex.startDocumentCount]
+        })
+      })]
+    }), /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+      gap: 5,
+      align: "center",
+      children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+        flex: 1,
+        children: /* @__PURE__ */jsxRuntime.jsx(ui.Label, {
+          size: 1,
+          muted: true,
+          children: "Failed documents"
+        })
+      }), /* @__PURE__ */jsxRuntime.jsx(ui.Stack, {
+        space: 2,
+        children: /* @__PURE__ */jsxRuntime.jsx(ui.Text, {
+          children: selectedIndex.failedDocumentCount
+        })
+      })]
+    })]
+  });
+}
+function useApiClient() {
+  const client = sanity.useClient({
+    apiVersion: "vX"
+  });
+  return require$$0.useMemo(() => client, [client]);
+}
+function EmbeddingsIndexTool() {
+  return /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
+    children: /* @__PURE__ */jsxRuntime.jsx(ui.Flex, {
+      justify: "center",
+      flex: 1,
+      children: /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
+        flex: 1,
+        style: {
+          maxWidth: 1200
+        },
+        padding: 5,
+        children: /* @__PURE__ */jsxRuntime.jsx(Indexes, {})
+      })
+    })
+  });
+}
+const NO_INDEXES = [];
+function Indexes() {
+  const client = useApiClient();
+  const [indexes, setIndexes] = require$$0.useState(NO_INDEXES);
+  const [loading, setLoading] = require$$0.useState(false);
+  const [error, setError] = require$$0.useState(false);
+  const [createIndexOpen, setCreateIndexOpen] = require$$0.useState(false);
+  const [selectedIndex, setSelectedIndex] = require$$0.useState(void 0);
+  const onCreateIndexClose = require$$0.useCallback(() => setCreateIndexOpen(false), []);
+  require$$0.useEffect(() => {
+    setSelectedIndex(indexes.find(i => i.indexName === (selectedIndex == null ? void 0 : selectedIndex.indexName)));
+  }, [indexes, selectedIndex]);
+  const updateIndexes = require$$0.useCallback(() => {
+    setLoading(true);
+    setError(false);
+    getIndexes(client).then(response => {
+      setLoading(false);
+      setIndexes(response);
+    }).catch(e => {
+      console.error(e);
+      setError(true);
+    }).finally(() => {
+      setLoading(false);
+    });
+  }, [client]);
+  const deleteNamedIndex = require$$0.useCallback(index => {
+    if (
+    // eslint-disable-next-line no-alert
+    !confirm("Are you sure you want to delete ".concat(index.indexName, " for dataset ").concat(index.dataset, "?"))) {
+      return;
+    }
+    setLoading(true);
+    setError(false);
+    deleteIndex(index.indexName, client).then(() => {
+      setTimeout(() => updateIndexes());
+    }).catch(e => {
+      console.error(e);
+      setError(true);
+    }).finally(() => {
+      setLoading(false);
+    });
+  }, [client, updateIndexes]);
+  const onSelectIndex = require$$0.useCallback(index => {
+    setSelectedIndex(index);
+    updateIndexes();
+  }, [setSelectedIndex, updateIndexes]);
+  require$$0.useEffect(() => {
+    updateIndexes();
+  }, [updateIndexes]);
+  const openCreate = require$$0.useCallback(() => setCreateIndexOpen(true), []);
+  const onSubmit = require$$0.useCallback(index => {
+    setIndexes(current => [...current, index]);
+    setSelectedIndex(index);
+    updateIndexes();
+  }, [updateIndexes]);
+  return /* @__PURE__ */jsxRuntime.jsxs(ui.Stack, {
+    space: 4,
+    children: [/* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
+      gap: 2,
+      align: "center",
+      style: {
+        height: 30
+      },
+      children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+        flex: 1,
+        children: /* @__PURE__ */jsxRuntime.jsx(ui.Heading, {
+          size: 1,
+          children: "Embeddings indexes"
+        })
+      }), /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
+        style: {
+          justifySelf: "flex-end"
+        },
+        children: /* @__PURE__ */jsxRuntime.jsx(ui.Button, {
+          icon: icons.AddIcon,
+          text: "New index",
+          tone: "default",
+          mode: "ghost",
+          onClick: openCreate
+        })
+      }), /* @__PURE__ */jsxRuntime.jsx(ui.Button, {
+        size: 1,
+        icon: loading ? /* @__PURE__ */jsxRuntime.jsx(ui.Spinner, {}) : icons.UndoIcon,
+        title: "Refresh index list",
+        tone: "default",
+        mode: "bleed",
+        onClick: updateIndexes,
+        disabled: loading
+      })]
+    }), error ? /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
+      tone: "critical",
+      padding: 2,
+      border: true,
+      children: "An error occurred. See console for details."
+    }) : null, /* @__PURE__ */jsxRuntime.jsx(IndexList, {
+      loading,
+      indexes,
+      selectedIndex,
+      onIndexSelected: onSelectIndex
+    }), selectedIndex && /* @__PURE__ */jsxRuntime.jsx(IndexInfo, {
+      selectedIndex,
+      onDeleteIndex: deleteNamedIndex
+    }), /* @__PURE__ */jsxRuntime.jsx(EditIndexDialog, {
+      open: createIndexOpen,
+      onClose: onCreateIndexClose,
+      onSubmit
+    })]
+  });
+}
+const embeddingsIndexTool = {
+  name: "embeddings-index",
+  title: "Embeddings",
+  icon: icons.EarthGlobeIcon,
+  component: EmbeddingsIndexTool
+};
+const embeddingsIndexDashboard = sanity.definePlugin({
+  name: "@sanity/embeddings-index-dashboard",
+  tools: [embeddingsIndexTool]
+});
+exports.deleteIndex = deleteIndex;
+exports.embeddingsIndexDashboard = embeddingsIndexDashboard;
+exports.embeddingsIndexReferenceInput = embeddingsIndexReferenceInput;
+exports.getIndexes = getIndexes;
+exports.queryIndex = queryIndex;
+//# sourceMappingURL=index.js.map