@sanity/embeddings-index-ui 2.0.1 → 2.1.1

package/dist/index.js

@@ -1,120 +1,547 @@
-'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 desk = require('sanity/desk');
-var router = require('sanity/router');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: !0 });
+var icons = require("@sanity/icons"), sanity = require("sanity"), jsxRuntime = require("react/jsx-runtime"), ui = require("@sanity/ui"), require$$0 = require("react"), router = require("sanity/router"), desk = require("sanity/desk");
 function _interopDefaultCompat(e) {
-  return e && typeof e === 'object' && 'default' in e ? e : {
-    default: e
-  };
+  return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
-var require$$0__default = /*#__PURE__*/_interopDefaultCompat(require$$0);
-function publicId(id) {
-  return id.replace("drafts.", "");
+var require$$0__default = /* @__PURE__ */ _interopDefaultCompat(require$$0);
+function queryIndex(queryConfig, client) {
+  const { query, indexName, maxResults, filter } = queryConfig, projectId = client.config().projectId, dataset = client.config().dataset, queryString = query?.trim();
+  return client.request({
+    method: "POST",
+    url: `/embeddings-index/query/${dataset}/${indexName}?projectId=${projectId}`,
+    body: {
+      query: queryString,
+      maxResults,
+      filter
+    }
+  });
 }
-function useApiClient() {
-  const client = sanity.useClient({
-    apiVersion: "vX"
+function getIndexes(client) {
+  const projectId = client.config().projectId, dataset = client.config().dataset;
+  return client.request({
+    method: "GET",
+    url: `/embeddings-index/${dataset}?projectId=${projectId}`
+  });
+}
+function deleteIndex(indexName, client) {
+  const projectId = client.config().projectId, dataset = client.config().dataset;
+  return client.request({
+    method: "DELETE",
+    url: `/embeddings-index/${dataset}/${indexName}?projectId=${projectId}`
   });
+}
+function useApiClient() {
+  const client = sanity.useClient({ apiVersion: "vX" });
   return require$$0.useMemo(() => {
     const customHost = localStorage.getItem("embeddings-index-host");
-    if (customHost) {
-      return client.withConfig({
-        apiHost: customHost,
-        useProjectHostname: false,
-        withCredentials: false
-      });
-    }
-    return client;
+    return customHost ? client.withConfig({
+      apiHost: customHost,
+      useProjectHostname: !1,
+      withCredentials: !1
+    }) : client;
   }, [client]);
 }
 const FeatureEnabledContext = require$$0.createContext("loading");
 function useIsFeatureEnabled() {
-  const client = useApiClient();
-  const [status, setStatus] = require$$0.useState("loading");
-  require$$0.useEffect(() => {
+  const client = useApiClient(), [status, setStatus] = require$$0.useState("loading");
+  return require$$0.useEffect(() => {
     client.request({
       method: "GET",
       url: "/embeddings-index/status"
-    }).then(response => {
+    }).then((response) => {
       setStatus(response.enabled ? "enabled" : "disabled");
-    }).catch(err => {
-      console.error(err);
-      setStatus("error");
+    }).catch((err) => {
+      console.error(err), setStatus("error");
     });
-  }, [client]);
-  return status;
+  }, [client]), status;
 }
 function FeatureEnabledProvider(props) {
   const status = useIsFeatureEnabled();
-  return /* @__PURE__ */jsxRuntime.jsx(FeatureEnabledContext.Provider, {
-    value: status,
-    children: props.children
-  });
+  return /* @__PURE__ */ jsxRuntime.jsx(FeatureEnabledContext.Provider, { value: status, children: props.children });
 }
 function useIsFeatureEnabledContext() {
   return require$$0.useContext(FeatureEnabledContext);
 }
 function FeatureDisabledNotice(props) {
-  var _a;
   const projectId = sanity.useProjectId();
-  return /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
-    tone: "primary",
-    border: true,
-    padding: 4,
-    children: /* @__PURE__ */jsxRuntime.jsxs(ui.Text, {
-      size: 1,
-      children: ["\u{1F48E} Unlock semantic search with the Embeddings Index API \u2014 available on Team, Business, and Enterprise plans.", " ", /* @__PURE__ */jsxRuntime.jsx("a", {
-        href: "https://www.sanity.io/manage/project/".concat(projectId, "/plan").concat((_a = props.urlSuffix) != null ? _a : ""),
-        children: "Upgrade now \u2192"
-      })]
-    })
-  });
+  return /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { tone: "primary", border: !0, padding: 4, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { size: 1, children: [
+    "\u{1F48E} Unlock semantic search with the Embeddings Index API \u2014 available on Team, Business, and Enterprise plans.",
+    " ",
+    /* @__PURE__ */ jsxRuntime.jsx("a", { href: `https://www.sanity.io/manage/project/${projectId}/plan${props.urlSuffix ?? ""}`, children: "Upgrade now \u2192" })
+  ] }) });
 }
 function FeatureError() {
-  return /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
-    padding: 4,
-    border: true,
-    tone: "critical",
-    children: "An error occurred. See console for details."
-  });
+  return /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { padding: 4, border: !0, tone: "critical", children: "An error occurred. See console for details." });
+}
+function isType(schemaType, typeName) {
+  return schemaType.name === typeName ? !0 : schemaType.type ? isType(schemaType.type, typeName) : !1;
+}
+const defaultProjection = "{...}";
+function useDefaultIndex(schema, dataset) {
+  const defaultFilter = require$$0.useMemo(
+    () => `_type in [${schema.getTypeNames().map((n) => schema.get(n)).filter(
+      (schemaType) => !!(schemaType && isType(schemaType, "document"))
+    ).filter(
+      (documentType) => !documentType.name.startsWith("sanity.") && !documentType.name.startsWith("assist.") && documentType.name !== "document"
+    ).map((documentType) => `"${documentType.name}"`).join(`,
+`)}]`,
+    [schema]
+  );
+  return require$$0.useMemo(
+    () => ({
+      dataset,
+      projection: defaultProjection,
+      filter: defaultFilter
+    }),
+    [defaultFilter, dataset]
+  );
+}
+function IndexFormInput(props) {
+  const { label, description, index, prop, onChange, readOnly, placeholder, type } = props, handleChange = require$$0.useCallback(
+    (propValue) => onChange((current) => ({ ...current, [prop]: propValue })),
+    [onChange, prop]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    FormInput,
+    {
+      label,
+      description,
+      onChange: handleChange,
+      value: index[prop] ?? "",
+      readOnly,
+      placeholder,
+      type
+    }
+  );
+}
+function FormInput(props) {
+  const { label, description, onChange, value, readOnly, placeholder, type = "text" } = props, id = require$$0.useId(), 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: !0, htmlFor: id, children: /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: id, children: label }) }),
+    description && /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { children: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { size: 1, muted: !0, children: description }) }),
+    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, id = require$$0.useId(), ref = require$$0.useRef(null);
+  require$$0.useEffect(() => {
+    open && setTimeout(() => ref.current?.querySelector("input")?.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: !1, onSubmit: handleSubmit }) }) }) : null;
+}
+function IndexEditor(props) {
+  const { readOnly, index: selectedIndex, onSubmit } = props, client = useApiClient(), schema = sanity.useSchema(), defaultIndex = useDefaultIndex(schema, client.config().dataset ?? ""), [errors, setErrors] = require$$0.useState(), [loading, setLoading] = require$$0.useState(), [index, setIndex] = require$$0.useState(() => ({
+    ...defaultIndex,
+    ...selectedIndex
+  }));
+  require$$0.useEffect(() => setIndex(selectedIndex ?? { ...defaultIndex }), [selectedIndex, defaultIndex]);
+  const handleSubmit = require$$0.useCallback(
+    (e) => {
+      if (e.preventDefault(), readOnly)
+        return;
+      const validationErrors = [];
+      if (index.indexName ? index.indexName.match(/^[a-zA-Z0-9-_]+$/g) || validationErrors.push("Index name can only contain the letters a-z, numbers - and _") : validationErrors.push("Index name is required"), index.dataset || validationErrors.push("Dataset is required"), index.filter || validationErrors.push("Filter is required"), index.projection || validationErrors.push("Projection is required"), validationErrors.length) {
+        setErrors(validationErrors);
+        return;
+      }
+      const { projectId } = client.config();
+      setLoading(!0), client.request({
+        method: "POST",
+        url: `/embeddings-index/${index.dataset}?projectId=${projectId}`,
+        body: {
+          indexName: index.indexName,
+          projection: index.projection,
+          filter: index.filter
+        }
+      }).then((response) => {
+        onSubmit && onSubmit(response.index);
+      }).catch((err) => {
+        console.error(err), setErrors([err.message]);
+      }).finally(() => {
+        setLoading(!1);
+      });
+    },
+    [index, readOnly, onSubmit, client]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx("form", { onSubmit: handleSubmit, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 4, children: [
+    errors?.length ? /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { tone: "critical", border: !0, padding: 2, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { children: /* @__PURE__ */ jsxRuntime.jsx("ul", { style: { marginLeft: -10 }, children: errors?.map((error, i) => /* @__PURE__ */ jsxRuntime.jsx("li", { children: error }, `${error}-${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: !0 }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      IndexFormInput,
+      {
+        label: "Filter",
+        description: "Must be a valid GROQ filter",
+        placeholder: defaultIndex.filter,
+        index,
+        prop: "filter",
+        onChange: setIndex,
+        readOnly,
+        type: "textarea"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      IndexFormInput,
+      {
+        label: "Projection",
+        description: "Must be a valid GROQ projection, starting { and ending with }",
+        placeholder: defaultIndex.projection,
+        index,
+        prop: "projection",
+        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"
+      }
+    )
+  ] }) });
 }
-
-/******************************************************************************
-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];
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @lightSyntaxTransform
+ * @noflow
+ * @nolint
+ * @preventMunge
+ * @preserve-invariant-messages
+ */
+var dist, hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  var __create = Object.create, __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: !0 });
+  }, __copyProps = (to, from2, except, desc) => {
+    if (from2 && typeof from2 == "object" || typeof from2 == "function")
+      for (let key of __getOwnPropNames(from2))
+        !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+    return to;
+  }, __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+    mod
+  )), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod), index_exports = {};
+  __export(index_exports, {
+    $dispatcherGuard: () => $dispatcherGuard,
+    $makeReadOnly: () => $makeReadOnly,
+    $reset: () => $reset,
+    $structuralCheck: () => $structuralCheck,
+    c: () => c,
+    clearRenderCounterRegistry: () => clearRenderCounterRegistry,
+    renderCounterRegistry: () => renderCounterRegistry,
+    useRenderCounter: () => useRenderCounter
+  }), dist = __toCommonJS(index_exports);
+  var React = __toESM(require$$0__default.default), { useRef, useEffect, isValidElement } = React, _a, ReactSecretInternals = (
+    //@ts-ignore
+    (_a = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE) != null ? _a : React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
+  ), $empty = Symbol.for("react.memo_cache_sentinel"), _a2, c = (
+    // @ts-expect-error
+    typeof ((_a2 = React.__COMPILER_RUNTIME) == null ? void 0 : _a2.c) == "function" ? (
+      // @ts-expect-error
+      React.__COMPILER_RUNTIME.c
+    ) : function(size) {
+      return React.useMemo(() => {
+        const $ = new Array(size);
+        for (let ii = 0; ii < size; ii++)
+          $[ii] = $empty;
+        return $[$empty] = !0, $;
+      }, []);
+    }
+  ), LazyGuardDispatcher = {};
+  [
+    "readContext",
+    "useCallback",
+    "useContext",
+    "useEffect",
+    "useImperativeHandle",
+    "useInsertionEffect",
+    "useLayoutEffect",
+    "useMemo",
+    "useReducer",
+    "useRef",
+    "useState",
+    "useDebugValue",
+    "useDeferredValue",
+    "useTransition",
+    "useMutableSource",
+    "useSyncExternalStore",
+    "useId",
+    "unstable_isNewReconciler",
+    "getCacheSignal",
+    "getCacheForType",
+    "useCacheRefresh"
+  ].forEach((name) => {
+    LazyGuardDispatcher[name] = () => {
+      throw new Error(
+        `[React] Unexpected React hook call (${name}) from a React compiled function. Check that all hooks are called directly and named according to convention ('use[A-Z]') `
+      );
+    };
+  });
+  var originalDispatcher = null;
+  LazyGuardDispatcher.useMemoCache = (count) => {
+    if (originalDispatcher == null)
+      throw new Error(
+        "React Compiler internal invariant violation: unexpected null dispatcher"
+      );
+    return originalDispatcher.useMemoCache(count);
   };
-  return extendStatics(d, b);
+  function setCurrent(newDispatcher) {
+    return ReactSecretInternals.ReactCurrentDispatcher.current = newDispatcher, ReactSecretInternals.ReactCurrentDispatcher.current;
+  }
+  var guardFrames = [];
+  function $dispatcherGuard(kind) {
+    const curr = ReactSecretInternals.ReactCurrentDispatcher.current;
+    if (kind === 0) {
+      if (guardFrames.push(curr), guardFrames.length === 1 && (originalDispatcher = curr), curr === LazyGuardDispatcher)
+        throw new Error(
+          "[React] Unexpected call to custom hook or component from a React compiled function. Check that (1) all hooks are called directly and named according to convention ('use[A-Z]') and (2) components are returned as JSX instead of being directly invoked."
+        );
+      setCurrent(LazyGuardDispatcher);
+    } else if (kind === 1) {
+      const lastFrame = guardFrames.pop();
+      if (lastFrame == null)
+        throw new Error(
+          "React Compiler internal error: unexpected null in guard stack"
+        );
+      guardFrames.length === 0 && (originalDispatcher = null), setCurrent(lastFrame);
+    } else if (kind === 2)
+      guardFrames.push(curr), setCurrent(originalDispatcher);
+    else if (kind === 3) {
+      const lastFrame = guardFrames.pop();
+      if (lastFrame == null)
+        throw new Error(
+          "React Compiler internal error: unexpected null in guard stack"
+        );
+      setCurrent(lastFrame);
+    } else
+      throw new Error("React Compiler internal error: unreachable block" + kind);
+  }
+  function $reset($) {
+    for (let ii = 0; ii < $.length; ii++)
+      $[ii] = $empty;
+  }
+  function $makeReadOnly() {
+    throw new Error("TODO: implement $makeReadOnly in react-compiler-runtime");
+  }
+  var renderCounterRegistry = /* @__PURE__ */ new Map();
+  function clearRenderCounterRegistry() {
+    for (const counters of renderCounterRegistry.values())
+      counters.forEach((counter) => {
+        counter.count = 0;
+      });
+  }
+  function registerRenderCounter(name, val) {
+    let counters = renderCounterRegistry.get(name);
+    counters == null && (counters = /* @__PURE__ */ new Set(), renderCounterRegistry.set(name, counters)), counters.add(val);
+  }
+  function removeRenderCounter(name, val) {
+    const counters = renderCounterRegistry.get(name);
+    counters?.delete(val);
+  }
+  function useRenderCounter(name) {
+    const val = useRef(null);
+    val.current != null && (val.current.count += 1), useEffect(() => {
+      if (val.current == null) {
+        const counter = { count: 0 };
+        registerRenderCounter(name, counter), val.current = counter;
+      }
+      return () => {
+        val.current !== null && removeRenderCounter(name, val.current);
+      };
+    });
+  }
+  var seenErrors = /* @__PURE__ */ new Set();
+  function $structuralCheck(oldValue, newValue, variableName, fnName, kind, loc) {
+    function error(l, r, path, depth) {
+      const str = `${fnName}:${loc} [${kind}] ${variableName}${path} changed from ${l} to ${r} at depth ${depth}`;
+      seenErrors.has(str) || (seenErrors.add(str), console.error(str));
+    }
+    const depthLimit = 2;
+    function recur(oldValue2, newValue2, path, depth) {
+      if (!(depth > depthLimit)) {
+        if (oldValue2 === newValue2)
+          return;
+        if (typeof oldValue2 != typeof newValue2)
+          error(`type ${typeof oldValue2}`, `type ${typeof newValue2}`, path, depth);
+        else if (typeof oldValue2 == "object") {
+          const oldArray = Array.isArray(oldValue2), newArray = Array.isArray(newValue2);
+          if (oldValue2 === null && newValue2 !== null)
+            error("null", `type ${typeof newValue2}`, path, depth);
+          else if (newValue2 === null)
+            error(`type ${typeof oldValue2}`, "null", path, depth);
+          else if (oldValue2 instanceof Map)
+            if (!(newValue2 instanceof Map))
+              error("Map instance", "other value", path, depth);
+            else if (oldValue2.size !== newValue2.size)
+              error(
+                `Map instance with size ${oldValue2.size}`,
+                `Map instance with size ${newValue2.size}`,
+                path,
+                depth
+              );
+            else
+              for (const [k, v] of oldValue2)
+                newValue2.has(k) ? recur(v, newValue2.get(k), `${path}.get(${k})`, depth + 1) : error(
+                  `Map instance with key ${k}`,
+                  `Map instance without key ${k}`,
+                  path,
+                  depth
+                );
+          else if (newValue2 instanceof Map)
+            error("other value", "Map instance", path, depth);
+          else if (oldValue2 instanceof Set)
+            if (!(newValue2 instanceof Set))
+              error("Set instance", "other value", path, depth);
+            else if (oldValue2.size !== newValue2.size)
+              error(
+                `Set instance with size ${oldValue2.size}`,
+                `Set instance with size ${newValue2.size}`,
+                path,
+                depth
+              );
+            else
+              for (const v of newValue2)
+                oldValue2.has(v) || error(
+                  `Set instance without element ${v}`,
+                  `Set instance with element ${v}`,
+                  path,
+                  depth
+                );
+          else if (newValue2 instanceof Set)
+            error("other value", "Set instance", path, depth);
+          else if (oldArray || newArray)
+            if (oldArray !== newArray)
+              error(
+                `type ${oldArray ? "array" : "object"}`,
+                `type ${newArray ? "array" : "object"}`,
+                path,
+                depth
+              );
+            else if (oldValue2.length !== newValue2.length)
+              error(
+                `array with length ${oldValue2.length}`,
+                `array with length ${newValue2.length}`,
+                path,
+                depth
+              );
+            else
+              for (let ii = 0; ii < oldValue2.length; ii++)
+                recur(oldValue2[ii], newValue2[ii], `${path}[${ii}]`, depth + 1);
+          else if (isValidElement(oldValue2) || isValidElement(newValue2))
+            isValidElement(oldValue2) !== isValidElement(newValue2) ? error(
+              `type ${isValidElement(oldValue2) ? "React element" : "object"}`,
+              `type ${isValidElement(newValue2) ? "React element" : "object"}`,
+              path,
+              depth
+            ) : oldValue2.type !== newValue2.type ? error(
+              `React element of type ${oldValue2.type}`,
+              `React element of type ${newValue2.type}`,
+              path,
+              depth
+            ) : recur(
+              oldValue2.props,
+              newValue2.props,
+              `[props of ${path}]`,
+              depth + 1
+            );
+          else {
+            for (const key in newValue2)
+              key in oldValue2 || error(
+                `object without key ${key}`,
+                `object with key ${key}`,
+                path,
+                depth
+              );
+            for (const key in oldValue2)
+              key in newValue2 ? recur(oldValue2[key], newValue2[key], `${path}.${key}`, depth + 1) : error(
+                `object with key ${key}`,
+                `object without key ${key}`,
+                path,
+                depth
+              );
+          }
+        } else {
+          if (typeof oldValue2 == "function")
+            return;
+          isNaN(oldValue2) || isNaN(newValue2) ? isNaN(oldValue2) !== isNaN(newValue2) && error(
+            `${isNaN(oldValue2) ? "NaN" : "non-NaN value"}`,
+            `${isNaN(newValue2) ? "NaN" : "non-NaN value"}`,
+            path,
+            depth
+          ) : oldValue2 !== newValue2 && error(oldValue2, newValue2, path, depth);
+        }
+      }
+    }
+    recur(oldValue, newValue, "", 0);
+  }
+  return dist;
+}
+var distExports = requireDist(), extendStatics = function(d, b) {
+  return extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2) Object.prototype.hasOwnProperty.call(b2, p) && (d2[p] = b2[p]);
+  }, extendStatics(d, b);
 };
 function __extends(d, b) {
-  if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  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;
@@ -123,11 +550,11 @@ function __extends(d, b) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function (resolve) {
+    return value instanceof P ? value : new P(function(resolve) {
       resolve(value);
     });
   }
-  return new (P || (P = Promise))(function (resolve, reject) {
+  return new (P || (P = Promise))(function(resolve, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -137,7 +564,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
     }
     function rejected(value) {
       try {
-        step(generator["throw"](value));
+        step(generator.throw(value));
       } catch (e) {
         reject(e);
       }
@@ -149,58 +576,37 @@ function __awaiter(thisArg, _arguments, P, generator) {
   });
 }
 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 () {
+  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 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]) {
+    for (; 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;
+      switch (y = 0, t && (op = [op[0] & 2, t.value]), op[0]) {
         case 0:
         case 1:
           t = op;
           break;
         case 4:
-          _.label++;
-          return {
-            value: op[1],
-            done: false
-          };
+          return _.label++, { value: op[1], done: !1 };
         case 5:
-          _.label++;
-          y = op[1];
-          op = [0];
+          _.label++, y = op[1], op = [0];
           continue;
         case 7:
-          op = _.ops.pop();
-          _.trys.pop();
+          op = _.ops.pop(), _.trys.pop();
           continue;
         default:
-          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+          if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
             _ = 0;
             continue;
           }
@@ -209,97 +615,73 @@ function __generator(thisArg, body) {
             break;
           }
           if (op[0] === 6 && _.label < t[1]) {
-            _.label = t[1];
-            t = op;
+            _.label = t[1], t = op;
             break;
           }
           if (t && _.label < t[2]) {
-            _.label = t[2];
-            _.ops.push(op);
+            _.label = t[2], _.ops.push(op);
             break;
           }
-          if (t[2]) _.ops.pop();
-          _.trys.pop();
+          t[2] && _.ops.pop(), _.trys.pop();
           continue;
       }
       op = body.call(thisArg, _);
     } catch (e) {
-      op = [6, e];
-      y = 0;
+      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
-    };
+    return { value: op[0] ? op[1] : void 0, done: !0 };
   }
 }
 function __values(o) {
-  var s = typeof Symbol === "function" && Symbol.iterator,
-    m = s && o[s],
-    i = 0;
+  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
-      };
+  if (o && typeof o.length == "number") return {
+    next: function() {
+      return o && i >= o.length && (o = void 0), { value: o && o[i++], done: !o };
     }
   };
   throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 }
 function __read(o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  var m = typeof Symbol == "function" && o[Symbol.iterator];
   if (!m) return o;
-  var i = m.call(o),
-    r,
-    ar = [],
-    e;
+  var i = m.call(o), r, ar = [], e;
   try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    for (; (n === void 0 || n-- > 0) && !(r = i.next()).done; ) ar.push(r.value);
   } catch (error) {
-    e = {
-      error: error
-    };
+    e = { error };
   } finally {
     try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
+      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 __spreadArray(to, from2, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from2.length, ar; i < l; i++)
+    (ar || !(i in from2)) && (ar || (ar = Array.prototype.slice.call(from2, 0, i)), ar[i] = from2[i]);
+  return to.concat(ar || Array.prototype.slice.call(from2));
 }
 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 () {
+  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) {
+    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 {
@@ -318,57 +700,44 @@ function __asyncGenerator(thisArg, _arguments, generator) {
     resume("throw", value);
   }
   function settle(f, v) {
-    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+    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 () {
+  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) {
+    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
-      });
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, 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';
+  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) {
+  var _super = function(instance) {
+    Error.call(instance), instance.stack = new Error().stack;
+  }, ctorFunc = createImpl(_super);
+  return ctorFunc.prototype = Object.create(Error.prototype), ctorFunc.prototype.constructor = ctorFunc, ctorFunc;
+}
+var UnsubscriptionError = createErrorClass(function(_super) {
+  return function(errors) {
+    _super(this), this.message = errors ? errors.length + ` errors occurred during unsubscription:
+` + errors.map(function(err, i) {
       return i + 1 + ") " + err.toString();
-    }).join('\n  ') : '';
-    this.name = 'UnsubscriptionError';
-    this.errors = errors;
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = errors;
   };
 });
 function arrRemove(arr, item) {
@@ -377,50 +746,40 @@ function arrRemove(arr, 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;
+var Subscription = function() {
+  function Subscription2(initialTeardown) {
+    this.initialTeardown = initialTeardown, this.closed = !1, this._parentage = null, this._finalizers = null;
   }
-  Subscription.prototype.unsubscribe = function () {
-    var e_1, _a, e_2, _b;
-    var errors;
+  return Subscription2.prototype.unsubscribe = function() {
+    var e_1, _a, e_2, _b, errors;
     if (!this.closed) {
-      this.closed = true;
+      this.closed = !0;
       var _parentage = this._parentage;
-      if (_parentage) {
-        this._parentage = null;
-        if (Array.isArray(_parentage)) {
+      if (_parentage)
+        if (this._parentage = null, Array.isArray(_parentage))
           try {
             for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
               var parent_1 = _parentage_1_1.value;
               parent_1.remove(this);
             }
           } catch (e_1_1) {
-            e_1 = {
-              error: e_1_1
-            };
+            e_1 = { error: e_1_1 };
           } finally {
             try {
-              if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+              _parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return) && _a.call(_parentage_1);
             } finally {
               if (e_1) throw e_1.error;
             }
           }
-        } else {
+        else
           _parentage.remove(this);
-        }
-      }
       var initialFinalizer = this.initialTeardown;
-      if (isFunction(initialFinalizer)) {
+      if (isFunction(initialFinalizer))
         try {
           initialFinalizer();
         } catch (e) {
           errors = e instanceof UnsubscriptionError ? e.errors : [e];
         }
-      }
       var _finalizers = this._finalizers;
       if (_finalizers) {
         this._finalizers = null;
@@ -430,330 +789,207 @@ var Subscription = function () {
             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);
-              }
+              errors = errors ?? [], err instanceof UnsubscriptionError ? errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors)) : errors.push(err);
             }
           }
         } catch (e_2_1) {
-          e_2 = {
-            error: e_2_1
-          };
+          e_2 = { error: e_2_1 };
         } finally {
           try {
-            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+            _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) {
+      if (errors)
         throw new UnsubscriptionError(errors);
-      }
     }
-  };
-  Subscription.prototype.add = function (teardown) {
+  }, Subscription2.prototype.add = function(teardown) {
     var _a;
-    if (teardown && teardown !== this) {
-      if (this.closed) {
+    if (teardown && teardown !== this)
+      if (this.closed)
         execFinalizer(teardown);
-      } else {
-        if (teardown instanceof Subscription) {
-          if (teardown.closed || teardown._hasParent(this)) {
+      else {
+        if (teardown instanceof Subscription2) {
+          if (teardown.closed || teardown._hasParent(this))
             return;
-          }
           teardown._addParent(this);
         }
         (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
       }
-    }
-  };
-  Subscription.prototype._hasParent = function (parent) {
+  }, Subscription2.prototype._hasParent = function(parent) {
     var _parentage = this._parentage;
     return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
-  };
-  Subscription.prototype._addParent = function (parent) {
+  }, Subscription2.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) {
+  }, Subscription2.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) {
+    _parentage === parent ? this._parentage = null : Array.isArray(_parentage) && arrRemove(_parentage, parent);
+  }, Subscription2.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;
+    _finalizers && arrRemove(_finalizers, teardown), teardown instanceof Subscription2 && teardown._removeParent(this);
+  }, Subscription2.EMPTY = function() {
+    var empty = new Subscription2();
+    return empty.closed = !0, empty;
+  }(), Subscription2;
+}(), EMPTY_SUBSCRIPTION = Subscription.EMPTY;
 function isSubscription(value) {
-  return value instanceof Subscription || value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+  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();
-  }
+  isFunction(finalizer) ? finalizer() : 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++) {
+  Promise: void 0
+}, timeoutProvider = {
+  setTimeout: function(handler, timeout) {
+    for (var args = [], _i = 2; _i < arguments.length; _i++)
       args[_i - 2] = arguments[_i];
-    }
     return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
   },
-  clearTimeout: function (handle) {
+  clearTimeout: function(handle) {
     return clearTimeout(handle);
   },
-  delegate: undefined
+  delegate: void 0
 };
 function reportUnhandledError(err) {
-  timeoutProvider.setTimeout(function () {
-    {
-      throw err;
-    }
+  timeoutProvider.setTimeout(function() {
+    throw err;
   });
 }
-function noop() {}
+function noop() {
+}
 function errorContext(cb) {
-  {
-    cb();
-  }
+  cb();
 }
-var Subscriber = function (_super) {
-  __extends(Subscriber, _super);
-  function Subscriber(destination) {
+var Subscriber = function(_super) {
+  __extends(Subscriber2, _super);
+  function Subscriber2(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;
+    return _this.isStopped = !1, destination ? (_this.destination = destination, isSubscription(destination) && destination.add(_this)) : _this.destination = EMPTY_OBSERVER, _this;
   }
-  Subscriber.create = function (next, error, complete) {
+  return Subscriber2.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) {
+  }, Subscriber2.prototype.next = function(value) {
+    this.isStopped || this._next(value);
+  }, Subscriber2.prototype.error = function(err) {
+    this.isStopped || (this.isStopped = !0, this._error(err));
+  }, Subscriber2.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, Subscriber2.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, _super.prototype.unsubscribe.call(this), this.destination = null);
+  }, Subscriber2.prototype._next = function(value) {
     this.destination.next(value);
-  };
-  Subscriber.prototype._error = function (err) {
+  }, Subscriber2.prototype._error = function(err) {
     try {
       this.destination.error(err);
     } finally {
       this.unsubscribe();
     }
-  };
-  Subscriber.prototype._complete = function () {
+  }, Subscriber2.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) {
+  }, Subscriber2;
+}(Subscription), ConsumerObserver = function() {
+  function ConsumerObserver2(partialObserver) {
     this.partialObserver = partialObserver;
   }
-  ConsumerObserver.prototype.next = function (value) {
+  return ConsumerObserver2.prototype.next = function(value) {
     var partialObserver = this.partialObserver;
-    if (partialObserver.next) {
+    if (partialObserver.next)
       try {
         partialObserver.next(value);
       } catch (error) {
         handleUnhandledError(error);
       }
-    }
-  };
-  ConsumerObserver.prototype.error = function (err) {
+  }, ConsumerObserver2.prototype.error = function(err) {
     var partialObserver = this.partialObserver;
-    if (partialObserver.error) {
+    if (partialObserver.error)
       try {
         partialObserver.error(err);
       } catch (error) {
         handleUnhandledError(error);
       }
-    } else {
+    else
       handleUnhandledError(err);
-    }
-  };
-  ConsumerObserver.prototype.complete = function () {
+  }, ConsumerObserver2.prototype.complete = function() {
     var partialObserver = this.partialObserver;
-    if (partialObserver.complete) {
+    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;
+  }, ConsumerObserver2;
+}(), SafeSubscriber = function(_super) {
+  __extends(SafeSubscriber2, _super);
+  function SafeSubscriber2(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this, partialObserver;
+    return isFunction(observerOrNext) || !observerOrNext ? partialObserver = {
+      next: observerOrNext ?? void 0,
+      error: error ?? void 0,
+      complete: complete ?? void 0
+    } : partialObserver = observerOrNext, _this.destination = new ConsumerObserver(partialObserver), _this;
   }
-  return SafeSubscriber;
+  return SafeSubscriber2;
 }(Subscriber);
 function handleUnhandledError(error) {
-  {
-    reportUnhandledError(error);
-  }
+  reportUnhandledError(error);
 }
 function defaultErrorHandler(err) {
   throw err;
 }
 var EMPTY_OBSERVER = {
-  closed: true,
+  closed: !0,
   next: noop,
   error: defaultErrorHandler,
   complete: noop
-};
-var observable = function () {
-  return typeof Symbol === 'function' && Symbol.observable || '@@observable';
+}, 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 fns.length === 0 ? identity : fns.length === 1 ? fns[0] : function(input) {
+    return fns.reduce(function(prev, fn) {
       return fn(prev);
     }, input);
   };
 }
-var Observable = function () {
-  function Observable(subscribe) {
-    if (subscribe) {
-      this._subscribe = subscribe;
-    }
+var Observable = function() {
+  function Observable2(subscribe) {
+    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;
+  return Observable2.prototype.lift = function(operator) {
+    var observable2 = new Observable2();
+    return observable2.source = this, observable2.operator = operator, observable2;
+  }, Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
+    var _this = this, subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+    return 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) {
+    }), subscriber;
+  }, Observable2.prototype._trySubscribe = function(sink) {
     try {
       return this._subscribe(sink);
     } catch (err) {
       sink.error(err);
     }
-  };
-  Observable.prototype.forEach = function (next, promiseCtor) {
+  }, Observable2.prototype.forEach = function(next, promiseCtor) {
     var _this = this;
-    promiseCtor = getPromiseCtor(promiseCtor);
-    return new promiseCtor(function (resolve, reject) {
+    return promiseCtor = getPromiseCtor(promiseCtor), new promiseCtor(function(resolve, reject) {
       var subscriber = new SafeSubscriber({
-        next: function (value) {
+        next: function(value) {
           try {
             next(value);
           } catch (err) {
-            reject(err);
-            subscriber.unsubscribe();
+            reject(err), subscriber.unsubscribe();
           }
         },
         error: reject,
@@ -761,43 +997,34 @@ var Observable = function () {
       });
       _this.subscribe(subscriber);
     });
-  };
-  Observable.prototype._subscribe = function (subscriber) {
+  }, Observable2.prototype._subscribe = function(subscriber) {
     var _a;
     return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
-  };
-  Observable.prototype[observable] = function () {
+  }, Observable2.prototype[observable] = function() {
     return this;
-  };
-  Observable.prototype.pipe = function () {
-    var operations = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
+  }, Observable2.prototype.pipe = function() {
+    for (var operations = [], _i = 0; _i < arguments.length; _i++)
       operations[_i] = arguments[_i];
-    }
     return pipeFromArray(operations)(this);
-  };
-  Observable.prototype.toPromise = function (promiseCtor) {
+  }, Observable2.prototype.toPromise = function(promiseCtor) {
     var _this = this;
-    promiseCtor = getPromiseCtor(promiseCtor);
-    return new promiseCtor(function (resolve, reject) {
+    return promiseCtor = getPromiseCtor(promiseCtor), new promiseCtor(function(resolve, reject) {
       var value;
-      _this.subscribe(function (x) {
+      _this.subscribe(function(x) {
         return value = x;
-      }, function (err) {
+      }, function(err) {
         return reject(err);
-      }, function () {
+      }, function() {
         return resolve(value);
       });
     });
-  };
-  Observable.create = function (subscribe) {
-    return new Observable(subscribe);
-  };
-  return Observable;
+  }, Observable2.create = function(subscribe) {
+    return new Observable2(subscribe);
+  }, Observable2;
 }();
 function getPromiseCtor(promiseCtor) {
   var _a;
-  return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+  return (_a = promiseCtor ?? config.Promise) !== null && _a !== void 0 ? _a : Promise;
 }
 function isObserver(value) {
   return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
@@ -806,48 +1033,43 @@ 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);
+  return isFunction(source?.lift);
 }
 function operate(init) {
-  return function (source) {
-    if (hasLift(source)) {
-      return source.lift(function (liftedSource) {
+  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');
+    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 OperatorSubscriber = function(_super) {
+  __extends(OperatorSubscriber2, _super);
+  function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
     var _this = _super.call(this, destination) || this;
-    _this.onFinalize = onFinalize;
-    _this.shouldUnsubscribe = shouldUnsubscribe;
-    _this._next = onNext ? function (value) {
+    return _this.onFinalize = onFinalize, _this.shouldUnsubscribe = shouldUnsubscribe, _this._next = onNext ? function(value) {
       try {
         onNext(value);
       } catch (err) {
         destination.error(err);
       }
-    } : _super.prototype._next;
-    _this._error = onError ? function (err) {
+    } : _super.prototype._next, _this._error = onError ? function(err) {
       try {
         onError(err);
-      } catch (err) {
-        destination.error(err);
+      } catch (err2) {
+        destination.error(err2);
       } finally {
         this.unsubscribe();
       }
-    } : _super.prototype._error;
-    _this._complete = onComplete ? function () {
+    } : _super.prototype._error, _this._complete = onComplete ? function() {
       try {
         onComplete();
       } catch (err) {
@@ -855,305 +1077,319 @@ var OperatorSubscriber = function (_super) {
       } finally {
         this.unsubscribe();
       }
-    } : _super.prototype._complete;
-    return _this;
+    } : _super.prototype._complete, _this;
   }
-  OperatorSubscriber.prototype.unsubscribe = function () {
+  return OperatorSubscriber2.prototype.unsubscribe = function() {
     var _a;
     if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
       var closed_1 = this.closed;
-      _super.prototype.unsubscribe.call(this);
-      !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+      _super.prototype.unsubscribe.call(this), !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 || _a.call(this));
     }
+  }, OperatorSubscriber2;
+}(Subscriber), ObjectUnsubscribedError = createErrorClass(function(_super) {
+  return function() {
+    _super(this), this.name = "ObjectUnsubscribedError", this.message = "object unsubscribed";
   };
-  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() {
+}), Subject = function(_super) {
+  __extends(Subject2, _super);
+  function Subject2() {
     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;
+    return _this.closed = !1, _this.currentObservers = null, _this.observers = [], _this.isStopped = !1, _this.hasError = !1, _this.thrownError = null, _this;
   }
-  Subject.prototype.lift = function (operator) {
+  return Subject2.prototype.lift = function(operator) {
     var subject = new AnonymousSubject(this, this);
-    subject.operator = operator;
-    return subject;
-  };
-  Subject.prototype._throwIfClosed = function () {
-    if (this.closed) {
+    return subject.operator = operator, subject;
+  }, Subject2.prototype._throwIfClosed = function() {
+    if (this.closed)
       throw new ObjectUnsubscribedError();
-    }
-  };
-  Subject.prototype.next = function (value) {
+  }, Subject2.prototype.next = function(value) {
     var _this = this;
-    errorContext(function () {
+    errorContext(function() {
       var e_1, _a;
-      _this._throwIfClosed();
-      if (!_this.isStopped) {
-        if (!_this.currentObservers) {
-          _this.currentObservers = Array.from(_this.observers);
-        }
+      if (_this._throwIfClosed(), !_this.isStopped) {
+        _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
-          };
+          e_1 = { error: e_1_1 };
         } finally {
           try {
-            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            _c && !_c.done && (_a = _b.return) && _a.call(_b);
           } finally {
             if (e_1) throw e_1.error;
           }
         }
       }
     });
-  };
-  Subject.prototype.error = function (err) {
+  }, Subject2.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) {
+    errorContext(function() {
+      if (_this._throwIfClosed(), !_this.isStopped) {
+        _this.hasError = _this.isStopped = !0, _this.thrownError = err;
+        for (var observers = _this.observers; observers.length; )
           observers.shift().error(err);
-        }
       }
     });
-  };
-  Subject.prototype.complete = function () {
+  }, Subject2.prototype.complete = function() {
     var _this = this;
-    errorContext(function () {
-      _this._throwIfClosed();
-      if (!_this.isStopped) {
-        _this.isStopped = true;
-        var observers = _this.observers;
-        while (observers.length) {
+    errorContext(function() {
+      if (_this._throwIfClosed(), !_this.isStopped) {
+        _this.isStopped = !0;
+        for (var observers = _this.observers; 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 () {
+  }, Subject2.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = !0, this.observers = this.currentObservers = null;
+  }, Object.defineProperty(Subject2.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) {
+    enumerable: !1,
+    configurable: !0
+  }), Subject2.prototype._trySubscribe = function(subscriber) {
+    return this._throwIfClosed(), _super.prototype._trySubscribe.call(this, subscriber);
+  }, Subject2.prototype._subscribe = function(subscriber) {
+    return this._throwIfClosed(), this._checkFinalizedStatuses(subscriber), this._innerSubscribe(subscriber);
+  }, Subject2.prototype._innerSubscribe = function(subscriber) {
+    var _this = this, _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+    return hasError || isStopped ? EMPTY_SUBSCRIPTION : (this.currentObservers = null, observers.push(subscriber), new Subscription(function() {
+      _this.currentObservers = null, arrRemove(observers, subscriber);
+    }));
+  }, Subject2.prototype._checkFinalizedStatuses = function(subscriber) {
+    var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+    hasError ? subscriber.error(thrownError) : isStopped && subscriber.complete();
+  }, Subject2.prototype.asObservable = function() {
+    var observable2 = new Observable();
+    return observable2.source = this, observable2;
+  }, Subject2.create = function(destination, source) {
     return new AnonymousSubject(destination, source);
-  };
-  return Subject;
-}(Observable);
-var AnonymousSubject = function (_super) {
-  __extends(AnonymousSubject, _super);
-  function AnonymousSubject(destination, source) {
+  }, Subject2;
+}(Observable), AnonymousSubject = function(_super) {
+  __extends(AnonymousSubject2, _super);
+  function AnonymousSubject2(destination, source) {
     var _this = _super.call(this) || this;
-    _this.destination = destination;
-    _this.source = source;
-    return _this;
+    return _this.destination = destination, _this.source = source, _this;
   }
-  AnonymousSubject.prototype.next = function (value) {
+  return AnonymousSubject2.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) {
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 || _b.call(_a, value);
+  }, AnonymousSubject2.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 () {
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 || _b.call(_a, err);
+  }, AnonymousSubject2.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) {
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 || _b.call(_a);
+  }, AnonymousSubject2.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();
+  }, AnonymousSubject2;
+}(Subject), dateTimestampProvider = {
+  now: function() {
+    return Date.now();
+  }
+}, Action = function(_super) {
+  __extends(Action2, _super);
+  function Action2(scheduler, work) {
+    return _super.call(this) || this;
+  }
+  return Action2.prototype.schedule = function(state, delay) {
+    return this;
+  }, Action2;
+}(Subscription), intervalProvider = {
+  setInterval: function(handler, timeout) {
+    for (var args = [], _i = 2; _i < arguments.length; _i++)
+      args[_i - 2] = arguments[_i];
+    return setInterval.apply(void 0, __spreadArray([handler, timeout], __read(args)));
   },
-  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;
+  clearInterval: function(handle) {
+    return clearInterval(handle);
+  },
+  delegate: void 0
+}, AsyncAction = function(_super) {
+  __extends(AsyncAction2, _super);
+  function AsyncAction2(scheduler, work) {
+    var _this = _super.call(this, scheduler, work) || this;
+    return _this.scheduler = scheduler, _this.work = work, _this.pending = !1, _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 AsyncAction2.prototype.schedule = function(state, delay) {
+    var _a;
+    if (delay === void 0 && (delay = 0), this.closed)
+      return this;
+    this.state = state;
+    var id = this.id, scheduler = this.scheduler;
+    return id != null && (this.id = this.recycleAsyncId(scheduler, id, delay)), this.pending = !0, this.delay = delay, this.id = (_a = this.id) !== null && _a !== void 0 ? _a : this.requestAsyncId(scheduler, this.id, delay), this;
+  }, AsyncAction2.prototype.requestAsyncId = function(scheduler, _id, delay) {
+    return delay === void 0 && (delay = 0), intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
+  }, AsyncAction2.prototype.recycleAsyncId = function(_scheduler, id, delay) {
+    if (delay === void 0 && (delay = 0), delay != null && this.delay === delay && this.pending === !1)
+      return id;
+    id != null && intervalProvider.clearInterval(id);
+  }, AsyncAction2.prototype.execute = function(state, delay) {
+    if (this.closed)
+      return new Error("executing a cancelled action");
+    this.pending = !1;
+    var error = this._execute(state, delay);
+    if (error)
+      return error;
+    this.pending === !1 && this.id != null && (this.id = this.recycleAsyncId(this.scheduler, this.id, null));
+  }, AsyncAction2.prototype._execute = function(state, _delay) {
+    var errored = !1, errorValue;
+    try {
+      this.work(state);
+    } catch (e) {
+      errored = !0, errorValue = e || new Error("Scheduled action threw falsy error");
     }
-  };
-  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);
+    if (errored)
+      return this.unsubscribe(), errorValue;
+  }, AsyncAction2.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      var _a = this, id = _a.id, scheduler = _a.scheduler, actions = scheduler.actions;
+      this.work = this.state = this.scheduler = null, this.pending = !1, arrRemove(actions, this), id != null && (this.id = this.recycleAsyncId(scheduler, id, null)), this.delay = null, _super.prototype.unsubscribe.call(this);
+    }
+  }, AsyncAction2;
+}(Action), nextHandle = 1, resolved, activeHandles = {};
+function findAndClearHandle(handle) {
+  return handle in activeHandles ? (delete activeHandles[handle], !0) : !1;
+}
+var Immediate = {
+  setImmediate: function(cb) {
+    var handle = nextHandle++;
+    return activeHandles[handle] = !0, resolved || (resolved = Promise.resolve()), resolved.then(function() {
+      return findAndClearHandle(handle) && cb();
+    }), handle;
+  },
+  clearImmediate: function(handle) {
+    findAndClearHandle(handle);
+  }
+}, setImmediate = Immediate.setImmediate, clearImmediate = Immediate.clearImmediate, immediateProvider = {
+  setImmediate: function() {
+    for (var args = [], _i = 0; _i < arguments.length; _i++)
+      args[_i] = arguments[_i];
+    var delegate = immediateProvider.delegate;
+    return (delegate?.setImmediate || setImmediate).apply(void 0, __spreadArray([], __read(args)));
+  },
+  clearImmediate: function(handle) {
+    return clearImmediate(handle);
+  },
+  delegate: void 0
+}, AsapAction = function(_super) {
+  __extends(AsapAction2, _super);
+  function AsapAction2(scheduler, work) {
+    var _this = _super.call(this, scheduler, work) || this;
+    return _this.scheduler = scheduler, _this.work = work, _this;
+  }
+  return AsapAction2.prototype.requestAsyncId = function(scheduler, id, delay) {
+    return delay === void 0 && (delay = 0), delay !== null && delay > 0 ? _super.prototype.requestAsyncId.call(this, scheduler, id, delay) : (scheduler.actions.push(this), scheduler._scheduled || (scheduler._scheduled = immediateProvider.setImmediate(scheduler.flush.bind(scheduler, void 0))));
+  }, AsapAction2.prototype.recycleAsyncId = function(scheduler, id, delay) {
+    var _a;
+    if (delay === void 0 && (delay = 0), delay != null ? delay > 0 : this.delay > 0)
+      return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay);
+    var actions = scheduler.actions;
+    id != null && ((_a = actions[actions.length - 1]) === null || _a === void 0 ? void 0 : _a.id) !== id && (immediateProvider.clearImmediate(id), scheduler._scheduled === id && (scheduler._scheduled = void 0));
+  }, AsapAction2;
+}(AsyncAction), Scheduler = function() {
+  function Scheduler2(schedulerActionCtor, now) {
+    now === void 0 && (now = Scheduler2.now), this.schedulerActionCtor = schedulerActionCtor, this.now = now;
+  }
+  return Scheduler2.prototype.schedule = function(work, delay, state) {
+    return delay === void 0 && (delay = 0), new this.schedulerActionCtor(this, work).schedule(state, delay);
+  }, Scheduler2.now = dateTimestampProvider.now, Scheduler2;
+}(), AsyncScheduler = function(_super) {
+  __extends(AsyncScheduler2, _super);
+  function AsyncScheduler2(SchedulerAction, now) {
+    now === void 0 && (now = Scheduler.now);
+    var _this = _super.call(this, SchedulerAction, now) || this;
+    return _this.actions = [], _this._active = !1, _this;
+  }
+  return AsyncScheduler2.prototype.flush = function(action) {
+    var actions = this.actions;
+    if (this._active) {
+      actions.push(action);
+      return;
+    }
+    var error;
+    this._active = !0;
+    do
+      if (error = action.execute(action.state, action.delay))
+        break;
+    while (action = actions.shift());
+    if (this._active = !1, error) {
+      for (; action = actions.shift(); )
+        action.unsubscribe();
+      throw error;
+    }
+  }, AsyncScheduler2;
+}(Scheduler), AsapScheduler = function(_super) {
+  __extends(AsapScheduler2, _super);
+  function AsapScheduler2() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  return AsapScheduler2.prototype.flush = function(action) {
+    this._active = !0;
+    var flushId = this._scheduled;
+    this._scheduled = void 0;
+    var actions = this.actions, error;
+    action = action || actions.shift();
+    do
+      if (error = action.execute(action.state, action.delay))
+        break;
+    while ((action = actions[0]) && action.id === flushId && actions.shift());
+    if (this._active = !1, error) {
+      for (; (action = actions[0]) && action.id === flushId && actions.shift(); )
+        action.unsubscribe();
+      throw error;
+    }
+  }, AsapScheduler2;
+}(AsyncScheduler), asapScheduler = new AsapScheduler(AsapAction), asyncScheduler = new AsyncScheduler(AsyncAction), async = asyncScheduler;
+function isScheduler(value) {
+  return value && isFunction(value.schedule);
+}
+function last(arr) {
+  return arr[arr.length - 1];
+}
+function popScheduler(args) {
+  return isScheduler(last(args)) ? args.pop() : void 0;
+}
+var isArrayLike = function(x) {
+  return x && typeof x.length == "number" && typeof x != "function";
+};
+function isPromise(value) {
+  return isFunction(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]);
+  return Symbol.asyncIterator && isFunction(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.");
+  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;
+  return typeof Symbol != "function" || !Symbol.iterator ? "@@iterator" : Symbol.iterator;
 }
 var iterator = getSymbolIterator();
 function isIterable(input) {
-  return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
+  return isFunction(input?.[iterator]);
 }
 function readableStreamLikeToAsyncGenerator(readableStream) {
-  return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
+  return __asyncGenerator(this, arguments, function() {
     var reader, _a, value, done;
-    return __generator(this, function (_b) {
+    return __generator(this, function(_b) {
       switch (_b.label) {
         case 0:
-          reader = readableStream.getReader();
-          _b.label = 1;
+          reader = readableStream.getReader(), _b.label = 1;
         case 1:
-          _b.trys.push([1,, 9, 10]);
-          _b.label = 2;
+          _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)];
+          return _a = _b.sent(), value = _a.value, done = _a.done, done ? [4, __await(void 0)] : [3, 5];
         case 4:
           return [2, _b.sent()];
         case 5:
@@ -1161,13 +1397,11 @@ function readableStreamLikeToAsyncGenerator(readableStream) {
         case 6:
           return [4, _b.sent()];
         case 7:
-          _b.sent();
-          return [3, 2];
+          return _b.sent(), [3, 2];
         case 8:
           return [3, 10];
         case 9:
-          reader.releaseLock();
-          return [7];
+          return reader.releaseLock(), [7];
         case 10:
           return [2];
       }
@@ -1175,81 +1409,65 @@ function readableStreamLikeToAsyncGenerator(readableStream) {
   });
 }
 function isReadableStreamLike(obj) {
-  return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
+  return isFunction(obj?.getReader);
 }
 function innerFrom(input) {
-  if (input instanceof Observable) {
+  if (input instanceof Observable)
     return input;
-  }
   if (input != null) {
-    if (isInteropObservable(input)) {
+    if (isInteropObservable(input))
       return fromInteropObservable(input);
-    }
-    if (isArrayLike(input)) {
+    if (isArrayLike(input))
       return fromArrayLike(input);
-    }
-    if (isPromise(input)) {
+    if (isPromise(input))
       return fromPromise(input);
-    }
-    if (isAsyncIterable(input)) {
+    if (isAsyncIterable(input))
       return fromAsyncIterable(input);
-    }
-    if (isIterable(input)) {
+    if (isIterable(input))
       return fromIterable(input);
-    }
-    if (isReadableStreamLike(input)) {
+    if (isReadableStreamLike(input))
       return fromReadableStreamLike(input);
-    }
   }
   throw createInvalidObservableTypeError(input);
 }
 function fromInteropObservable(obj) {
-  return new Observable(function (subscriber) {
+  return new Observable(function(subscriber) {
     var obs = obj[observable]();
-    if (isFunction(obs.subscribe)) {
+    if (isFunction(obs.subscribe))
       return obs.subscribe(subscriber);
-    }
-    throw new TypeError('Provided object does not correctly implement Symbol.observable');
+    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++) {
+  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 new Observable(function(subscriber) {
+    promise.then(function(value) {
+      subscriber.closed || (subscriber.next(value), subscriber.complete());
+    }, function(err) {
       return subscriber.error(err);
     }).then(null, reportUnhandledError);
   });
 }
 function fromIterable(iterable) {
-  return new Observable(function (subscriber) {
+  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) {
+        if (subscriber.next(value), subscriber.closed)
           return;
-        }
       }
     } catch (e_1_1) {
-      e_1 = {
-        error: 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);
+        iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return) && _a.call(iterable_1);
       } finally {
         if (e_1) throw e_1.error;
       }
@@ -1258,8 +1476,8 @@ function fromIterable(iterable) {
   });
 }
 function fromAsyncIterable(asyncIterable) {
-  return new Observable(function (subscriber) {
-    process$1(asyncIterable, subscriber).catch(function (err) {
+  return new Observable(function(subscriber) {
+    process(asyncIterable, subscriber).catch(function(err) {
       return subscriber.error(err);
     });
   });
@@ -1267,44 +1485,31 @@ function fromAsyncIterable(asyncIterable) {
 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 () {
+function process(asyncIterable, subscriber) {
+  var asyncIterable_1, asyncIterable_1_1, e_2, _a;
+  return __awaiter(this, void 0, void 0, function() {
     var value, e_2_1;
-    return __generator(this, function (_b) {
+    return __generator(this, function(_b) {
       switch (_b.label) {
         case 0:
-          _b.trys.push([0, 5, 6, 11]);
-          asyncIterable_1 = __asyncValues(asyncIterable);
-          _b.label = 1;
+          _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) {
+          if (asyncIterable_1_1 = _b.sent(), !!asyncIterable_1_1.done) return [3, 4];
+          if (value = asyncIterable_1_1.value, subscriber.next(value), 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];
+          return e_2_1 = _b.sent(), e_2 = { error: e_2_1 }, [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)];
+          return _b.trys.push([6, , 9, 10]), asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return) ? [4, _a.call(asyncIterable_1)] : [3, 8];
         case 7:
-          _b.sent();
-          _b.label = 8;
+          _b.sent(), _b.label = 8;
         case 8:
           return [3, 10];
         case 9:
@@ -1313,653 +1518,383 @@ function process$1(asyncIterable, subscriber) {
         case 10:
           return [7];
         case 11:
-          subscriber.complete();
-          return [2];
+          return subscriber.complete(), [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;
+function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
+  delay === void 0 && (delay = 0), repeat === void 0 && (repeat = !1);
+  var scheduleSubscription = scheduler.schedule(function() {
+    work(), repeat ? parentSubscription.add(this.schedule(null, delay)) : this.unsubscribe();
+  }, delay);
+  if (parentSubscription.add(scheduleSubscription), !repeat)
+    return scheduleSubscription;
+}
+function observeOn(scheduler, delay) {
+  return delay === void 0 && (delay = 0), operate(function(source, subscriber) {
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      return executeSchedule(subscriber, scheduler, function() {
+        return subscriber.next(value);
+      }, delay);
+    }, function() {
+      return executeSchedule(subscriber, scheduler, function() {
+        return subscriber.complete();
+      }, delay);
+    }, function(err) {
+      return executeSchedule(subscriber, scheduler, function() {
+        return subscriber.error(err);
+      }, delay);
+    }));
+  });
+}
+function subscribeOn(scheduler, delay) {
+  return delay === void 0 && (delay = 0), operate(function(source, subscriber) {
+    subscriber.add(scheduler.schedule(function() {
+      return source.subscribe(subscriber);
+    }, delay));
+  });
+}
+function scheduleObservable(input, scheduler) {
+  return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+function schedulePromise(input, scheduler) {
+  return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+function scheduleArray(input, scheduler) {
+  return new Observable(function(subscriber) {
+    var i = 0;
+    return scheduler.schedule(function() {
+      i === input.length ? subscriber.complete() : (subscriber.next(input[i++]), subscriber.closed || this.schedule());
+    });
+  });
+}
+function scheduleIterable(input, scheduler) {
+  return new Observable(function(subscriber) {
+    var iterator$1;
+    return executeSchedule(subscriber, scheduler, function() {
+      iterator$1 = input[iterator](), executeSchedule(subscriber, scheduler, function() {
+        var _a, value, done;
+        try {
+          _a = iterator$1.next(), value = _a.value, done = _a.done;
+        } catch (err) {
+          subscriber.error(err);
+          return;
+        }
+        done ? subscriber.complete() : subscriber.next(value);
+      }, 0, !0);
+    }), function() {
+      return isFunction(iterator$1?.return) && iterator$1.return();
     };
-    var resetAndUnsubscribe = function () {
+  });
+}
+function scheduleAsyncIterable(input, scheduler) {
+  if (!input)
+    throw new Error("Iterable cannot be null");
+  return new Observable(function(subscriber) {
+    executeSchedule(subscriber, scheduler, function() {
+      var iterator2 = input[Symbol.asyncIterator]();
+      executeSchedule(subscriber, scheduler, function() {
+        iterator2.next().then(function(result) {
+          result.done ? subscriber.complete() : subscriber.next(result.value);
+        });
+      }, 0, !0);
+    });
+  });
+}
+function scheduleReadableStreamLike(input, scheduler) {
+  return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
+}
+function scheduled(input, scheduler) {
+  if (input != null) {
+    if (isInteropObservable(input))
+      return scheduleObservable(input, scheduler);
+    if (isArrayLike(input))
+      return scheduleArray(input, scheduler);
+    if (isPromise(input))
+      return schedulePromise(input, scheduler);
+    if (isAsyncIterable(input))
+      return scheduleAsyncIterable(input, scheduler);
+    if (isIterable(input))
+      return scheduleIterable(input, scheduler);
+    if (isReadableStreamLike(input))
+      return scheduleReadableStreamLike(input, scheduler);
+  }
+  throw createInvalidObservableTypeError(input);
+}
+function from(input, scheduler) {
+  return scheduler ? scheduled(input, scheduler) : innerFrom(input);
+}
+function of() {
+  for (var args = [], _i = 0; _i < arguments.length; _i++)
+    args[_i] = arguments[_i];
+  var scheduler = popScheduler(args);
+  return from(args, scheduler);
+}
+function isValidDate(value) {
+  return value instanceof Date && !isNaN(value);
+}
+function map(project, thisArg) {
+  return operate(function(source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      subscriber.next(project.call(thisArg, value, index++));
+    }));
+  });
+}
+function timer(dueTime, intervalOrScheduler, scheduler) {
+  scheduler === void 0 && (scheduler = async);
+  var intervalDuration = -1;
+  return intervalOrScheduler != null && (isScheduler(intervalOrScheduler) ? scheduler = intervalOrScheduler : intervalDuration = intervalOrScheduler), new Observable(function(subscriber) {
+    var due = isValidDate(dueTime) ? 0 - scheduler.now() : dueTime;
+    due < 0 && (due = 0);
+    var n = 0;
+    return scheduler.schedule(function() {
+      subscriber.closed || (subscriber.next(n++), 0 <= intervalDuration ? this.schedule(void 0, intervalDuration) : subscriber.complete());
+    }, due);
+  });
+}
+function catchError(selector) {
+  return operate(function(source, subscriber) {
+    var innerSub = null, syncUnsub = !1, handledResult;
+    innerSub = source.subscribe(createOperatorSubscriber(subscriber, void 0, void 0, function(err) {
+      handledResult = innerFrom(selector(err, catchError(selector)(source))), innerSub ? (innerSub.unsubscribe(), innerSub = null, handledResult.subscribe(subscriber)) : syncUnsub = !0;
+    })), syncUnsub && (innerSub.unsubscribe(), innerSub = null, handledResult.subscribe(subscriber));
+  });
+}
+function finalize(callback) {
+  return operate(function(source, subscriber) {
+    try {
+      source.subscribe(subscriber);
+    } finally {
+      subscriber.add(callback);
+    }
+  });
+}
+function share(options) {
+  options === void 0 && (options = {});
+  var _a = options.connector, connector = _a === void 0 ? function() {
+    return new Subject();
+  } : _a, _b = options.resetOnError, resetOnError = _b === void 0 ? !0 : _b, _c = options.resetOnComplete, resetOnComplete = _c === void 0 ? !0 : _c, _d = options.resetOnRefCountZero, resetOnRefCountZero = _d === void 0 ? !0 : _d;
+  return function(wrapperSource) {
+    var connection, resetConnection, subject, refCount = 0, hasCompleted = !1, hasErrored = !1, cancelReset = function() {
+      resetConnection?.unsubscribe(), resetConnection = void 0;
+    }, reset = function() {
+      cancelReset(), connection = subject = void 0, hasCompleted = hasErrored = !1;
+    }, resetAndUnsubscribe = function() {
       var conn = connection;
-      reset();
-      conn === null || conn === void 0 ? void 0 : conn.unsubscribe();
+      reset(), 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);
+    return operate(function(source, subscriber) {
+      refCount++, !hasErrored && !hasCompleted && cancelReset();
+      var dest = subject = subject ?? connector();
+      subscriber.add(function() {
+        refCount--, refCount === 0 && !hasErrored && !hasCompleted && (resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero));
+      }), dest.subscribe(subscriber), !connection && refCount > 0 && (connection = new SafeSubscriber({
+        next: function(value) {
+          return dest.next(value);
+        },
+        error: function(err) {
+          hasErrored = !0, cancelReset(), resetConnection = handleReset(reset, resetOnError, err), dest.error(err);
+        },
+        complete: function() {
+          hasCompleted = !0, cancelReset(), resetConnection = handleReset(reset, resetOnComplete), dest.complete();
         }
-      });
-      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);
-      }
+      }), innerFrom(source).subscribe(connection));
     })(wrapperSource);
   };
 }
 function handleReset(reset, on) {
-  var args = [];
-  for (var _i = 2; _i < arguments.length; _i++) {
+  for (var args = [], _i = 2; _i < arguments.length; _i++)
     args[_i - 2] = arguments[_i];
-  }
-  if (on === true) {
+  if (on === !0) {
     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;
+  if (on !== !1) {
+    var onSubscriber = new SafeSubscriber({
+      next: function() {
+        onSubscriber.unsubscribe(), reset();
+      }
+    });
+    return innerFrom(on.apply(void 0, __spreadArray([], __read(args)))).subscribe(onSubscriber);
   }
-  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 tapObserver = isFunction(observerOrNext) || error || complete ? { next: observerOrNext, error, 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);
+    (_a = tapObserver.subscribe) === null || _a === void 0 || _a.call(tapObserver);
+    var isUnsub = !0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      var _a2;
+      (_a2 = tapObserver.next) === null || _a2 === void 0 || _a2.call(tapObserver, value), subscriber.next(value);
+    }, function() {
+      var _a2;
+      isUnsub = !1, (_a2 = tapObserver.complete) === null || _a2 === void 0 || _a2.call(tapObserver), subscriber.complete();
+    }, function(err) {
+      var _a2;
+      isUnsub = !1, (_a2 = tapObserver.error) === null || _a2 === void 0 || _a2.call(tapObserver, err), subscriber.error(err);
+    }, function() {
+      var _a2, _b;
+      isUnsub && ((_a2 = tapObserver.unsubscribe) === null || _a2 === void 0 || _a2.call(tapObserver)), (_b = tapObserver.finalize) === null || _b === 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 typeof value == "function" ? value() : value;
+}
+const cache = /* @__PURE__ */ new WeakMap();
+function useObservable(observable2, initialValue) {
+  const $ = distExports.c(9);
+  let t0;
+  if (!cache.has(observable2)) {
+    const state = {
+      didEmit: !1
+    }, entry = {
+      state,
+      observable: observable2.pipe(map(_temp$1), catchError(_temp2), tap((t12) => {
+        const {
+          snapshot,
+          error: error_0
+        } = t12;
+        state.didEmit = !0, state.snapshot = snapshot, state.error = error_0;
+      }), map(_temp3), finalize(() => cache.delete(observable2)), share({
+        resetOnRefCountZero: _temp4
+      })),
+      getSnapshot: (initialValue_0) => {
+        if (state.error)
+          throw state.error;
+        return state.didEmit ? state.snapshot : getValue(initialValue_0);
       }
-      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,
-    schemaTypeName,
-    ...buttonProps
-  } = _ref;
-  const schema = sanity.useSchema();
-  const schemaType = schemaTypeName ? schema.get(schemaTypeName) : void 0;
-  if (!schemaTypeName) {
-    return /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
-      style: {
-        minHeight: "36px"
-      },
-      children: /* @__PURE__ */jsxRuntime.jsx(sanity.DefaultPreview, {
-        withShadow: false,
-        withBorder: false,
-        title: "Loading...",
-        schemaType,
-        isPlaceholder: true
-      })
-    });
+    entry.observable.subscribe().unsubscribe(), cache.set(observable2, entry);
   }
-  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: schemaTypeName != null ? schemaTypeName : "N/A"
-          }), " for ", documentId]
-        })
-      })
-    });
-  }
-  return /* @__PURE__ */jsxRuntime.jsx(DocumentPreviewInner, {
-    documentId,
-    schemaTypeName,
-    schemaType,
-    style,
-    ...buttonProps
+  let t1;
+  $[0] !== observable2 ? (t1 = cache.get(observable2), $[0] = observable2, $[1] = t1) : t1 = $[1], t0 = t1;
+  const instance = t0;
+  let t2;
+  $[2] !== instance.observable ? (t2 = (onStoreChange) => {
+    const subscription_0 = instance.observable.subscribe(onStoreChange);
+    return () => {
+      subscription_0.unsubscribe();
+    };
+  }, $[2] = instance.observable, $[3] = t2) : t2 = $[3];
+  const subscribe = t2;
+  let t3;
+  $[4] !== initialValue || $[5] !== instance ? (t3 = () => instance.getSnapshot(initialValue), $[4] = initialValue, $[5] = instance, $[6] = t3) : t3 = $[6];
+  let t4;
+  return $[7] !== initialValue ? (t4 = typeof initialValue > "u" ? void 0 : () => getValue(initialValue), $[7] = initialValue, $[8] = t4) : t4 = $[8], require$$0.useSyncExternalStore(subscribe, t3, t4);
+}
+function _temp4() {
+  return timer(0, asapScheduler);
+}
+function _temp3(value_0) {
+}
+function _temp2(error) {
+  return of({
+    snapshot: void 0,
+    error
   });
 }
-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({
+function _temp$1(value) {
+  return {
+    snapshot: value,
+    error: void 0
+  };
+}
+function DocumentPreview({
+  documentId,
+  style,
+  schemaTypeName,
+  ...buttonProps
+}) {
+  const schema = sanity.useSchema(), schemaType = schemaTypeName ? schema.get(schemaTypeName) : void 0;
+  return schemaTypeName ? schemaType ? /* @__PURE__ */ jsxRuntime.jsx(
+    DocumentPreviewInner,
+    {
+      documentId,
+      schemaTypeName,
+      schemaType,
+      style,
+      ...buttonProps
+    }
+  ) : /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { children: /* @__PURE__ */ jsxRuntime.jsx(
+    sanity.DefaultPreview,
+    {
+      withShadow: !1,
+      withBorder: !1,
+      media: () => /* @__PURE__ */ jsxRuntime.jsx(icons.ErrorOutlineIcon, {}),
+      title: /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        "Unknown type ",
+        /* @__PURE__ */ jsxRuntime.jsx("code", { children: schemaTypeName ?? "N/A" }),
+        " for ",
+        documentId
+      ] })
+    }
+  ) }) : /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { style: { minHeight: "36px" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+    sanity.DefaultPreview,
+    {
+      withShadow: !1,
+      withBorder: !1,
+      title: "Loading...",
+      schemaType,
+      isPlaceholder: !0
+    }
+  ) });
+}
+function DocumentPreviewInner({
+  documentId,
+  schemaType,
+  style,
+  button
+}) {
+  const documentPreviewStore = sanity.useDocumentPreviewStore(), previewStateObservable = require$$0.useMemo(
+    () => sanity.getPreviewStateObservable(documentPreviewStore, schemaType, documentId),
+    [documentId, documentPreviewStore, schemaType]
+  ), {
+    snapshot,
+    original,
+    isLoading: previewIsLoading
+  } = useObservable(previewStateObservable, {
+    snapshot: null,
+    isLoading: !0,
+    original: null
+  }), sanityDocument = require$$0.useMemo(() => ({
+    _id: documentId,
+    _type: schemaType?.name
+  }), [documentId, schemaType?.name]), { onClick: onIntentClick, href } = router.useIntentLink({
     intent: "edit",
     params: {
       id: documentId,
-      type: schemaType == null ? void 0 : schemaType.name
+      type: 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, {
+  }), preview = /* @__PURE__ */ jsxRuntime.jsx(
+    sanity.SanityDefaultPreview,
+    {
+      ...sanity.getPreviewValueWithFallback({
+        snapshot,
+        original,
+        fallback: sanityDocument
+      }),
+      isPlaceholder: previewIsLoading ?? !0,
+      layout: "default",
+      icon: schemaType?.icon
+    }
+  );
+  return button ? /* @__PURE__ */ jsxRuntime.jsx(
+    ui.Button,
+    {
       as: "a",
       href,
       onClick: onIntentClick,
       mode: "ghost",
-      style: {
-        width: "100%",
-        ...style
-      },
+      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)
-  });
+  ) : /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { style: { width: "100%" }, children: preview });
 }
-const NO_RESULTS_VALUE = "";
-const NO_OPTIONS = [];
-const NO_FILTER = () => true;
-const SemanticSearchAutocomplete = require$$0.forwardRef(function SemanticSearchAutocomplete2(props, ref) {
+const NO_RESULTS_VALUE = "", NO_OPTIONS = [], NO_FILTER = () => !0, SemanticSearchAutocomplete = require$$0.forwardRef(function(props, ref) {
   const {
     indexConfig,
     filterResult,
@@ -1969,943 +1904,445 @@ const SemanticSearchAutocomplete = require$$0.forwardRef(function SemanticSearch
     onBlur,
     onSelect,
     typeFilter
-  } = props;
-  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();
-  const runIndexQuery = require$$0.useCallback(queryString => {
-    var _a;
-    setSearching(true);
-    const indexName = indexConfig == null ? void 0 : indexConfig.indexName;
-    const maxResults = indexConfig == null ? void 0 : indexConfig.maxResults;
-    if (!indexName) {
-      throw new Error("Reference option embeddingsIndex.indexName is required, but was missing");
-    }
-    queryIndex({
-      query: queryString.trim().length ? queryString : (_a = getEmptySearchValue()) != null ? _a : "",
-      indexName,
-      maxResults,
-      filter: {
-        type: typeFilter
-      }
-    }, client).then(result => {
-      if (queryRef.current === queryString) {
-        setSearching(false);
-        setOptions([]);
-        const resultOptions = result.filter(hit => filterResult ? filterResult(hit) : true).map(r => sanity.typed({
-          result: r,
-          value: r.value.documentId
-        }));
-        if (resultOptions.length) {
-          setOptions(resultOptions);
-        } else {
-          setOptions([{
-            value: NO_RESULTS_VALUE
-          }]);
+  } = props, id = require$$0.useId(), [query, setQuery] = require$$0.useState(""), queryRef = require$$0.useRef(query), debouncedQuery = useDebouncedValue(query, 300), prevDebouncedQuery = require$$0.useRef(debouncedQuery), [searching, setSearching] = require$$0.useState(!1), [options, setOptions] = require$$0.useState(NO_OPTIONS), client = useApiClient(), runIndexQuery = require$$0.useCallback(
+    (queryString) => {
+      setSearching(!0);
+      const indexName = indexConfig?.indexName, maxResults = indexConfig?.maxResults;
+      if (!indexName)
+        throw new Error("Reference option embeddingsIndex.indexName is required, but was missing");
+      queryIndex(
+        {
+          query: queryString.trim().length ? queryString : getEmptySearchValue() ?? "",
+          indexName,
+          maxResults,
+          filter: {
+            type: typeFilter
+          }
+        },
+        client
+      ).then((result) => {
+        if (queryRef.current === queryString) {
+          setSearching(!1), setOptions([]), setOptions([]);
+          const resultOptions = result.filter((hit) => filterResult ? filterResult(hit) : !0).map((r) => sanity.typed({ result: r, value: r.value.documentId }));
+          resultOptions.length ? setOptions(resultOptions) : setOptions([{ value: NO_RESULTS_VALUE }]);
         }
-      }
-    }).catch(e => {
-      if (queryRef.current === queryString) {
-        setSearching(false);
-      }
-      throw e;
-    });
-  }, [client, indexConfig, getEmptySearchValue, filterResult, typeFilter]);
+      }).catch((e) => {
+        throw queryRef.current === queryString && setSearching(!1), e;
+      });
+    },
+    [client, indexConfig, getEmptySearchValue, filterResult, typeFilter]
+  );
   require$$0.useEffect(() => {
-    if (prevDebouncedQuery.current !== debouncedQuery) {
-      runIndexQuery(debouncedQuery);
-    }
-    prevDebouncedQuery.current = debouncedQuery;
+    prevDebouncedQuery.current !== debouncedQuery && runIndexQuery(debouncedQuery), prevDebouncedQuery.current = debouncedQuery;
   }, [debouncedQuery, runIndexQuery]);
-  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]);
-  const handleChange = require$$0.useCallback(value => {
-    if (value === NO_RESULTS_VALUE) {
-      setOptions(NO_OPTIONS);
-      return;
-    }
-    const option = options.filter(r => "result" in r).find(r => r.result.value.documentId === value);
-    if (option && onSelect) {
-      onSelect(option.result);
+  const openButtonConfig = require$$0.useMemo(
+    () => ({ onClick: () => runIndexQuery(queryRef.current) }),
+    [runIndexQuery, queryRef]
+  ), handleQueryChange = require$$0.useCallback(
+    (newValue) => {
+      const newQuery = newValue ?? "";
+      queryRef.current = newQuery, setQuery(newQuery);
+    },
+    [setQuery]
+  ), handleChange = require$$0.useCallback(
+    (value) => {
+      if (value === NO_RESULTS_VALUE) {
+        setOptions(NO_OPTIONS);
+        return;
+      }
+      const option = options.filter((r) => "result" in r).find((r) => r.result.value.documentId === value);
+      option && onSelect && onSelect(option.result);
+    },
+    [onSelect, options]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ui.Autocomplete,
+    {
+      id,
+      ref,
+      "data-testid": "semantic-autocomplete",
+      placeholder: "Type to search...",
+      openButton: openButtonConfig,
+      onFocus,
+      onChange: handleChange,
+      loading: searching,
+      onBlur,
+      readOnly,
+      filterOption: NO_FILTER,
+      onQueryChange: handleQueryChange,
+      options,
+      renderOption: AutocompleteOption
     }
-  }, [onSelect, options]);
-  return /* @__PURE__ */jsxRuntime.jsx(ui.Autocomplete, {
-    id,
-    ref,
-    "data-testid": "semantic-autocomplete",
-    placeholder: "Type to search...",
-    openButton: openButtonConfig,
-    onFocus,
-    onChange: handleChange,
-    loading: searching,
-    onBlur,
-    readOnly,
-    filterOption: NO_FILTER,
-    onQueryChange: handleQueryChange,
-    options,
-    renderOption: AutocompleteOption
-  });
+  );
 });
 function AutocompleteOption(props) {
   if ("result" in props) {
     const value = props.result.value;
-    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: value.documentId,
-            schemaTypeName: value.type
-          })
-        }), /* @__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), "%"]
-          })
-        })]
-      })
-    });
+    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: value.documentId, schemaTypeName: value.type }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding: 2, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Text, { size: 1, muted: !0, title: "Relevance", children: [
+        Math.floor(props.result.score * 100),
+        "%"
+      ] }) })
+    ] }) });
   }
-  return /* @__PURE__ */jsxRuntime.jsx(ui.Button, {
-    mode: "bleed",
-    padding: 1,
-    style: {
-      width: "100%"
-    },
-    disabled: true,
-    children: /* @__PURE__ */jsxRuntime.jsx(ui.Flex, {
-      gap: 2,
-      align: "center",
-      children: "No results."
-    })
-  });
+  return /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { mode: "bleed", padding: 1, style: { width: "100%" }, disabled: !0, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Flex, { gap: 2, align: "center", children: "No results." }) });
 }
 function useDebouncedValue(value, ms) {
   const [debouncedValue, setDebouncedValue] = require$$0.useState(value);
-  require$$0.useEffect(() => {
+  return require$$0.useEffect(() => {
     const timeoutId = setTimeout(() => {
       setDebouncedValue(value);
     }, ms);
     return () => clearTimeout(timeoutId);
-  }, [value, ms]);
-  return debouncedValue;
-}
-function useEmeddingsConfig(embeddingsIndexConfig, defaultConfig) {
-  return require$$0.useMemo(() => {
-    if (embeddingsIndexConfig === true || !embeddingsIndexConfig) {
-      if (!(defaultConfig == null ? void 0 : defaultConfig.indexName)) {
-        throw new Error("Default embeddingsIndex config is missing. When options.embeddingsIndex: true, embeddingsIndexReferenceInput plugin config is required.");
-      }
-      return defaultConfig;
-    }
-    const finalConfig = {
-      ...defaultConfig,
-      ...embeddingsIndexConfig
-    };
-    if (!(finalConfig == null ? void 0 : finalConfig.indexName)) {
-      throw new Error("indexName is missing. Either set it in options.embeddingsIndex or configure defaults using plugin config.");
-    }
-    return finalConfig;
-  }, [defaultConfig, embeddingsIndexConfig]);
-}
-function SemanticSearchReferenceInput(props) {
-  var _a, _b;
-  const embeddingsIndexConfig = (_b = (_a = props.schemaType) == null ? void 0 : _a.options) == null ? void 0 : _b.embeddingsIndex;
-  const config = useEmeddingsConfig(embeddingsIndexConfig, props.defaultConfig);
-  const defaultEnabled = config.searchMode === "embeddings";
-  const featureState = useIsFeatureEnabledContext();
-  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: [semantic && featureState == "loading" ? /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
-      padding: 2,
-      children: /* @__PURE__ */jsxRuntime.jsx(ui.Spinner, {})
-    }) : null, semantic && featureState == "disabled" ? /* @__PURE__ */jsxRuntime.jsx(FeatureDisabledNotice, {
-      urlSuffix: "?ref=embeddings-ref"
-    }) : null, semantic && featureState === "error" ? /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
-      padding: 4,
-      children: /* @__PURE__ */jsxRuntime.jsx(FeatureError, {})
-    }) : null, /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
-      flex: 1,
-      style: {
-        maxHeight: 36,
-        overflow: "hidden"
-      },
-      children: semantic && featureState == "enabled" ? /* @__PURE__ */jsxRuntime.jsx(SemanticSearchInput, {
-        ...props,
-        indexConfig: config
-      }) : 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 SemanticSearchInput(props) {
-  const {
-    indexConfig,
-    onPathFocus,
-    onChange,
-    readOnly,
-    schemaType,
-    value
-  } = props;
-  const {
-    value: currentDocument
-  } = desk.useDocumentPane();
-  const docRef = require$$0.useRef(currentDocument);
-  const autocompleteRef = require$$0.useRef(null);
-  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 handleChange = require$$0.useCallback(result => {
-    if (!result) {
-      onChange(sanity.unset());
-      onPathFocus([]);
-      return;
-    }
-    const patches = [sanity.setIfMissing({}), sanity.set(schemaType.name, ["_type"]), sanity.set(publicId(result.value.documentId), ["_ref"]), sanity.unset(["_weak"]), sanity.unset(["_strengthenOnPublish"])];
-    onChange(patches);
-    onPathFocus([]);
-  }, [onChange, onPathFocus, schemaType.name]);
-  const filterResult = require$$0.useCallback(r => r.value.documentId !== publicId(docRef.current._id), [docRef]);
-  const getEmptySearchValue = require$$0.useCallback(() => JSON.stringify(docRef.current), [docRef]);
-  const typeFilter = require$$0.useMemo(() => schemaType.to.map(refType => refType.name), [schemaType]);
-  return /* @__PURE__ */jsxRuntime.jsx(SemanticSearchAutocomplete, {
-    ref: autocompleteRef,
-    typeFilter,
-    indexConfig,
-    onSelect: handleChange,
-    onFocus: handleFocus,
-    onBlur: handleBlur,
-    getEmptySearchValue,
-    filterResult,
-    readOnly
-  });
-}
-function isType(schemaType, typeName) {
-  if (schemaType.name === typeName) {
-    return true;
-  }
-  if (!schemaType.type) {
-    return false;
-  }
-  return isType(schemaType.type, typeName);
-}
-const embeddingsIndexReferenceInput = sanity.definePlugin(defaultConfig => {
-  const config = typeof defaultConfig === "object" ? defaultConfig : void 0;
-  return {
-    name: "@sanity/embeddings-index-reference-input",
-    studio: {
-      components: {
-        layout: props => {
-          return /* @__PURE__ */jsxRuntime.jsx(FeatureEnabledProvider, {
-            children: props.renderDefault(props)
-          });
-        }
-      }
-    },
-    form: {
-      components: {
-        input: props => {
-          var _a, _b;
-          const embeddingsIndexConfig = (_b = (_a = props.schemaType) == null ? void 0 : _a.options) == null ? void 0 : _b.embeddingsIndex;
-          if (sanity.isObjectInputProps(props) && isType(props.schemaType, "reference") && (embeddingsIndexConfig === true || (embeddingsIndexConfig == null ? void 0 : embeddingsIndexConfig.indexName))) {
-            return /* @__PURE__ */jsxRuntime.jsx(SemanticSearchReferenceInput, {
-              ...props,
-              defaultConfig: config
-            });
-          }
-          return props.renderDefault(props);
-        }
-      }
-    }
-  };
-});
-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,
-    description,
-    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,
-    description,
-    onChange: handleChange,
-    value: (_a = index[prop]) != null ? _a : "",
-    readOnly,
-    placeholder,
-    type
-  });
-}
-function FormInput(props) {
-  const {
-    label,
-    description,
-    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
-      })
-    }), description && /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
-      children: /* @__PURE__ */jsxRuntime.jsx(ui.Text, {
-        size: 1,
-        muted: true,
-        children: description
-      })
-    }), 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();
-  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: "Filter",
-        description: "Must be a valid GROQ filter",
-        placeholder: defaultIndex.filter,
-        index,
-        prop: "filter",
-        onChange: setIndex,
-        readOnly,
-        type: "textarea"
-      }), /* @__PURE__ */jsxRuntime.jsx(IndexFormInput, {
-        label: "Projection",
-        description: "Must be a valid GROQ projection, starting { and ending with }",
-        placeholder: defaultIndex.projection,
-        index,
-        prop: "projection",
-        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,
-        padding: 3,
-        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" : "ghost",
-    onClick: onSelect,
-    padding: 3,
-    children: /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
-      children: [/* @__PURE__ */jsxRuntime.jsx(ui.Box, {
-        flex: 1,
-        children: /* @__PURE__ */jsxRuntime.jsx("strong", {
-          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);
+  }, [value, ms]), debouncedValue;
 }
 function QueryIndex(props) {
-  const {
-    indexName
-  } = props;
-  const getEmpty = require$$0.useCallback(() => "anything", []);
-  const indexConfig = require$$0.useMemo(() => ({
-    indexName,
-    maxResults: 8
-  }), [indexName]);
-  const {
-    resolveIntentLink,
-    navigateUrl
-  } = router.useRouter();
-  const onSelect = require$$0.useCallback(hit => {
-    navigateUrl({
-      path: resolveIntentLink("edit", {
-        id: hit.value.documentId,
-        type: hit.value.type
-      })
-    });
-  }, [resolveIntentLink, navigateUrl]);
-  return /* @__PURE__ */jsxRuntime.jsx(SemanticSearchAutocomplete, {
-    getEmptySearchValue: getEmpty,
-    indexConfig,
-    onSelect
-  });
-}
-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, {
+  const { indexName } = props, getEmpty = require$$0.useCallback(() => "anything", []), indexConfig = require$$0.useMemo(
+    () => ({ indexName, maxResults: 8 }),
+    [indexName]
+  ), { resolveIntentLink, navigateUrl } = router.useRouter(), onSelect = require$$0.useCallback(
+    (hit) => {
+      navigateUrl({
+        path: resolveIntentLink("edit", { id: hit.value.documentId, type: hit.value.type })
+      });
+    },
+    [resolveIntentLink, navigateUrl]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SemanticSearchAutocomplete,
+    {
+      getEmptySearchValue: getEmpty,
+      indexConfig,
+      onSelect
+    }
+  );
+}
+function IndexInfo({ selectedIndex, onDeleteIndex }) {
+  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: ",
+        selectedIndex?.indexName ?? "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-${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)]
-      })]
-    })]
-  });
+            }
+          ) }),
+          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: !0 }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(IndexStatus, { selectedIndex })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(ui.Stack, { space: 3, flex: 1, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { muted: !0, children: "Query index" }),
+        /* @__PURE__ */ jsxRuntime.jsx(QueryIndex, { indexName: selectedIndex.indexName }, selectedIndex.indexName)
+      ] })
+    ] })
+  ] });
+}
+function IndexStatus({ selectedIndex }) {
+  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: !0, 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: !0, 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: !0, children: "Failed documents" }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Stack, { space: 2, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Text, { children: selectedIndex.failedDocumentCount }) })
+    ] })
+  ] });
 }
-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 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: !0, flex: 1, paddingBottom: 2, padding: 3, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { muted: !0, children: "Index name" }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { muted: !0, children: "Dataset" }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { muted: !0, children: "Status" }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { muted: !0, 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: !0, children: "No indexes found." })
+  ] }) });
+}
+function IndexRow(props) {
+  const { selectedIndex, index, onIndexSelected } = props, onSelect = require$$0.useCallback(() => onIndexSelected(index), [onIndexSelected, index]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ui.Button,
+    {
+      tone: selectedIndex?.indexName === index.indexName ? "primary" : "default",
+      mode: selectedIndex?.indexName === index.indexName ? "default" : "ghost",
+      onClick: onSelect,
+      padding: 3,
+      children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1, children: /* @__PURE__ */ jsxRuntime.jsx("strong", { 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
+  );
 }
 function EmbeddingsIndexTool() {
   const featureState = useIsFeatureEnabled();
-  return /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
-    flex: 1,
-    children: /* @__PURE__ */jsxRuntime.jsxs(ui.Flex, {
-      justify: "center",
-      flex: 1,
-      children: [featureState === "error" ? /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
-        padding: 4,
-        children: /* @__PURE__ */jsxRuntime.jsx(FeatureError, {})
-      }) : null, featureState === "disabled" ? /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
-        padding: 4,
-        children: /* @__PURE__ */jsxRuntime.jsx(FeatureDisabledNotice, {
-          urlSuffix: "?ref=embeddings-tab"
-        })
-      }) : null, featureState === "loading" ? /* @__PURE__ */jsxRuntime.jsx(ui.Box, {
-        padding: 6,
-        children: /* @__PURE__ */jsxRuntime.jsx(ui.Spinner, {
-          size: 4
-        })
-      }) : null, featureState === "enabled" ? /* @__PURE__ */jsxRuntime.jsx(ui.Card, {
-        flex: 1,
-        style: {
-          maxWidth: 1200
-        },
-        padding: 5,
-        children: /* @__PURE__ */jsxRuntime.jsx(Indexes, {})
-      }) : null]
-    })
-  });
+  return /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { flex: 1, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { justify: "center", flex: 1, children: [
+    featureState === "error" ? /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding: 4, children: /* @__PURE__ */ jsxRuntime.jsx(FeatureError, {}) }) : null,
+    featureState === "disabled" ? /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding: 4, children: /* @__PURE__ */ jsxRuntime.jsx(FeatureDisabledNotice, { urlSuffix: "?ref=embeddings-tab" }) }) : null,
+    featureState === "loading" ? /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding: 6, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Spinner, { size: 4 }) }) : null,
+    featureState === "enabled" ? /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { flex: 1, style: { maxWidth: 1200 }, padding: 5, children: /* @__PURE__ */ jsxRuntime.jsx(Indexes, {}) }) : null
+  ] }) });
 }
 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), []);
+  const client = useApiClient(), [indexes, setIndexes] = require$$0.useState(NO_INDEXES), [loading, setLoading] = require$$0.useState(!1), [error, setError] = require$$0.useState(!1), [createIndexOpen, setCreateIndexOpen] = require$$0.useState(!1), [selectedIndex, setSelectedIndex] = require$$0.useState(void 0), onCreateIndexClose = require$$0.useCallback(() => setCreateIndexOpen(!1), []);
   require$$0.useEffect(() => {
-    setSelectedIndex(indexes.find(i => i.indexName === (selectedIndex == null ? void 0 : selectedIndex.indexName)));
+    setSelectedIndex(indexes.find((i) => i.indexName === 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);
+    setLoading(!0), setError(!1), getIndexes(client).then((response) => {
+      setLoading(!1), setIndexes(response);
+    }).catch((e) => {
+      console.error(e), setError(!0);
     }).finally(() => {
-      setLoading(false);
+      setLoading(!1);
     });
-  }, [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]);
+  }, [client]), deleteNamedIndex = require$$0.useCallback(
+    (index) => {
+      confirm(`Are you sure you want to delete ${index.indexName} for dataset ${index.dataset}?`) && (setLoading(!0), setError(!1), deleteIndex(index.indexName, client).then(() => {
+        setTimeout(() => updateIndexes());
+      }).catch((e) => {
+        console.error(e), setError(!0);
+      }).finally(() => {
+        setLoading(!1);
+      }));
+    },
+    [client, updateIndexes]
+  ), 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, {
+  const openCreate = require$$0.useCallback(() => setCreateIndexOpen(!0), []), 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
-    })]
-  });
+        }
+      ) }),
+      /* @__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: !0, 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({
+}, embeddingsIndexDashboard = sanity.definePlugin({
   name: "@sanity/embeddings-index-dashboard",
   tools: [embeddingsIndexTool]
 });
+function publicId(id) {
+  return id.replace("drafts.", "");
+}
+function useEmeddingsConfig(embeddingsIndexConfig, defaultConfig) {
+  return require$$0.useMemo(() => {
+    if (embeddingsIndexConfig === !0 || !embeddingsIndexConfig) {
+      if (!defaultConfig?.indexName)
+        throw new Error(
+          "Default embeddingsIndex config is missing. When options.embeddingsIndex: true, embeddingsIndexReferenceInput plugin config is required."
+        );
+      return defaultConfig;
+    }
+    const finalConfig = {
+      ...defaultConfig,
+      ...embeddingsIndexConfig
+    };
+    if (!finalConfig?.indexName)
+      throw new Error(
+        "indexName is missing. Either set it in options.embeddingsIndex or configure defaults using plugin config."
+      );
+    return finalConfig;
+  }, [defaultConfig, embeddingsIndexConfig]);
+}
+function SemanticSearchReferenceInput(props) {
+  const embeddingsIndexConfig = props.schemaType?.options?.embeddingsIndex, config2 = useEmeddingsConfig(embeddingsIndexConfig, props.defaultConfig), defaultEnabled = config2.searchMode === "embeddings", featureState = useIsFeatureEnabledContext(), [semantic, setSemantic] = require$$0.useState(defaultEnabled), toggleSemantic = require$$0.useCallback(() => setSemantic((current) => !current), []);
+  return /* @__PURE__ */ jsxRuntime.jsxs(ui.Flex, { gap: 2, flex: 1, style: { width: "100%" }, children: [
+    semantic && featureState == "loading" ? /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding: 2, children: /* @__PURE__ */ jsxRuntime.jsx(ui.Spinner, {}) }) : null,
+    semantic && featureState == "disabled" ? /* @__PURE__ */ jsxRuntime.jsx(FeatureDisabledNotice, { urlSuffix: "?ref=embeddings-ref" }) : null,
+    semantic && featureState === "error" ? /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { padding: 4, children: /* @__PURE__ */ jsxRuntime.jsx(FeatureError, {}) }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx(ui.Box, { flex: 1, style: { maxHeight: 36, overflow: "hidden" }, children: semantic && featureState == "enabled" ? /* @__PURE__ */ jsxRuntime.jsx(SemanticSearchInput, { ...props, indexConfig: config2 }) : 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 SemanticSearchInput(props) {
+  const { indexConfig, onPathFocus, onChange, readOnly, schemaType, value } = props, { value: currentDocument } = desk.useDocumentPane(), docRef = require$$0.useRef(currentDocument), autocompleteRef = require$$0.useRef(null);
+  require$$0.useEffect(() => {
+    docRef.current = currentDocument;
+  }, [currentDocument]), require$$0.useEffect(() => {
+    value?._ref && autocompleteRef.current?.focus();
+  }, []);
+  const handleFocus = require$$0.useCallback(() => onPathFocus(["_ref"]), [onPathFocus]), handleBlur = require$$0.useCallback(() => onPathFocus([]), [onPathFocus]), handleChange = require$$0.useCallback(
+    (result) => {
+      if (!result) {
+        onChange(sanity.unset()), onPathFocus([]);
+        return;
+      }
+      const patches = [
+        sanity.setIfMissing({}),
+        sanity.set(schemaType.name, ["_type"]),
+        sanity.set(publicId(result.value.documentId), ["_ref"]),
+        sanity.unset(["_weak"]),
+        sanity.unset(["_strengthenOnPublish"])
+      ];
+      onChange(patches), onPathFocus([]);
+    },
+    [onChange, onPathFocus, schemaType.name]
+  ), filterResult = require$$0.useCallback(
+    (r) => r.value.documentId !== publicId(docRef.current._id),
+    [docRef]
+  ), getEmptySearchValue = require$$0.useCallback(() => JSON.stringify(docRef.current), [docRef]), typeFilter = require$$0.useMemo(
+    () => schemaType.to.map((refType) => refType.name),
+    [schemaType]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SemanticSearchAutocomplete,
+    {
+      ref: autocompleteRef,
+      typeFilter,
+      indexConfig,
+      onSelect: handleChange,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      getEmptySearchValue,
+      filterResult,
+      readOnly
+    }
+  );
+}
+const embeddingsIndexReferenceInput = sanity.definePlugin(
+  (defaultConfig) => {
+    const config2 = typeof defaultConfig == "object" ? defaultConfig : void 0;
+    return {
+      name: "@sanity/embeddings-index-reference-input",
+      studio: {
+        components: {
+          layout: (props) => /* @__PURE__ */ jsxRuntime.jsx(FeatureEnabledProvider, { children: props.renderDefault(props) })
+        }
+      },
+      form: {
+        components: {
+          input: (props) => {
+            const embeddingsIndexConfig = props.schemaType?.options?.embeddingsIndex;
+            return sanity.isObjectInputProps(props) && isType(props.schemaType, "reference") && (embeddingsIndexConfig === !0 || embeddingsIndexConfig?.indexName) ? /* @__PURE__ */ jsxRuntime.jsx(
+              SemanticSearchReferenceInput,
+              {
+                ...props,
+                defaultConfig: config2
+              }
+            ) : props.renderDefault(props);
+          }
+        }
+      }
+    };
+  }
+);
 exports.deleteIndex = deleteIndex;
 exports.embeddingsIndexDashboard = embeddingsIndexDashboard;
 exports.embeddingsIndexReferenceInput = embeddingsIndexReferenceInput;