@sanity/sdk 0.0.0-chore-react-18-compat.0 → 0.0.0-chore-react-18-compat.1

package/dist/index.cjs

@@ -0,0 +1,4888 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: !0 });
+var client = require("@sanity/client"), rxjs = require("rxjs"), middleware = require("zustand/middleware"), vanilla = require("zustand/vanilla"), reselect = require("reselect"), lodashEs = require("lodash-es"), comlink = require("@sanity/comlink"), operators = require("rxjs/operators"), mutate = require("@sanity/mutate"), csm = require("@sanity/client/csm"), diffMatchPatch$1 = require("@sanity/diff-match-patch"), types = require("@sanity/types"), _unstable_store = require("@sanity/mutate/_unstable_store"), _documentCurrentScript = typeof document < "u" ? document.currentScript : null, AuthStateType = /* @__PURE__ */ ((AuthStateType2) => (AuthStateType2.LOGGED_IN = "logged-in", AuthStateType2.LOGGING_IN = "logging-in", AuthStateType2.ERROR = "error", AuthStateType2.LOGGED_OUT = "logged-out", AuthStateType2))(AuthStateType || {});
+function getEnv(key) {
+  if (typeof { url: typeof document > "u" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index.cjs", document.baseURI).href } < "u", typeof process < "u" && process.env)
+    return process.env[key];
+  if (typeof window < "u" && window.ENV)
+    return window.ENV?.[key];
+}
+const resourceCache = /* @__PURE__ */ new WeakMap();
+function createResourceState(initialState, devToolsOptions) {
+  const store = vanilla.createStore()(middleware.devtools(() => initialState, devToolsOptions));
+  return {
+    get: store.getState,
+    set: (actionKey, updatedState) => {
+      store.getState() !== updatedState && store.setState(updatedState, !1, actionKey);
+    },
+    observable: new rxjs.Observable((observer) => {
+      const emit = () => observer.next(store.getState());
+      return emit(), store.subscribe(emit);
+    })
+  };
+}
+function initializeResource(instance, resource) {
+  const fullName = resource.name === "Auth" ? "Auth-global" : `${resource.name}-${instance.identity.resourceId}`, initialState = resource.getInitialState(instance), state = createResourceState(initialState, {
+    name: fullName,
+    enabled: !!getEnv("DEV")
+  }), dispose = resource.initialize?.call({ instance, state }, instance) ?? (() => {
+  });
+  return { state, dispose };
+}
+function getOrCreateResource(instance, resource) {
+  const fullName = resource.name === "Auth" ? "Auth-global" : `${resource.name}-${instance.identity.resourceId}`;
+  resourceCache.has(instance.identity) || resourceCache.set(instance.identity, /* @__PURE__ */ new Map());
+  const initializedResources = resourceCache.get(instance.identity), cached = initializedResources.get(fullName);
+  if (cached) return cached;
+  const result = initializeResource(instance, resource);
+  return initializedResources.set(fullName, result), result;
+}
+function disposeResources(identity) {
+  const resources = resourceCache.get(identity);
+  if (resources)
+    for (const resource of resources.values())
+      resource.dispose();
+}
+function createAction(resource, actionDefinition) {
+  return (dependencies, ...args) => {
+    const instance = "state" in dependencies ? dependencies.instance : dependencies, { state } = "state" in dependencies ? dependencies : getOrCreateResource(dependencies, resource), actionContext = { instance, state };
+    return actionDefinition(actionContext).bind(actionContext)(...args);
+  };
+}
+function createInternalAction(actionDefinition) {
+  return (actionContext, ...args) => actionDefinition(actionContext).bind(actionContext)(...args);
+}
+function createStateSourceAction(resource, options) {
+  const selector = typeof options == "function" ? options : options.selector, subscribeHandler = options && "onSubscribe" in options ? options.onSubscribe : void 0, isEqual = options && "isEqual" in options ? options.isEqual ?? Object.is : Object.is;
+  return createAction(resource, ({ state }) => function(...args) {
+    const getCurrent = () => selector(state.get(), ...args), subscribe = (onStoreChanged) => {
+      const cleanup = subscribeHandler?.(this, ...args), subscription = state.observable.pipe(
+        rxjs.map(getCurrent),
+        rxjs.distinctUntilChanged(isEqual),
+        // skip the first emission because we only want to emit when the
+        // value changes. `distinctUntilChanged` will always emit the first
+        // the first value so we skip this emission
+        rxjs.skip(1)
+      ).subscribe({
+        next: () => onStoreChanged?.(),
+        // the convention is to have the selector throw the error so we
+        // invoke onStoreChanged on error as well. this will cause the
+        // observable code path below to emit an error because the selector
+        // will throw and that will be used to emit an .error on the observer
+        error: () => onStoreChanged?.()
+      });
+      return () => {
+        subscription.unsubscribe(), cleanup?.();
+      };
+    }, observable = new rxjs.Observable((observer) => {
+      const emitCurrent = () => {
+        try {
+          observer.next(getCurrent());
+        } catch (error) {
+          observer.error(error);
+        }
+      };
+      return emitCurrent(), subscribe(emitCurrent);
+    }).pipe(rxjs.share());
+    return {
+      getCurrent,
+      subscribe,
+      observable
+    };
+  });
+}
+const DEFAULT_BASE = "http://localhost", AUTH_CODE_PARAM = "sid", DEFAULT_API_VERSION$1 = "2021-06-07", REQUEST_TAG_PREFIX = "sanity.sdk.auth", refreshStampedToken = createInternalAction(
+  ({ state }) => {
+    const { clientFactory, apiHost, storageArea, storageKey } = state.get().options, refreshToken$ = state.observable.pipe(
+      rxjs.map(({ authState }) => authState),
+      rxjs.filter(
+        (authState) => authState.type === AuthStateType.LOGGED_IN
+      ),
+      rxjs.distinctUntilChanged(),
+      rxjs.filter((authState) => authState.token.includes("-st")),
+      // Ensure we only try to refresh stamped tokens
+      rxjs.switchMap(
+        (authState) => rxjs.interval(10 * 60 * 1e3).pipe(
+          rxjs.takeWhile(() => state.get().authState.type === AuthStateType.LOGGED_IN),
+          rxjs.map(() => authState.token),
+          rxjs.distinctUntilChanged(),
+          rxjs.map(
+            (token) => clientFactory({
+              apiVersion: DEFAULT_API_VERSION$1,
+              requestTagPrefix: "sdk.token-refresh",
+              useProjectHostname: !1,
+              token,
+              ignoreBrowserTokenWarning: !0,
+              ...apiHost && { apiHost }
+            })
+          ),
+          rxjs.switchMap(
+            (client2) => client2.observable.request({
+              uri: "auth/refresh-token",
+              method: "POST",
+              body: {
+                token: authState.token
+              }
+            })
+          )
+        )
+      )
+    );
+    return function() {
+      return refreshToken$.subscribe({
+        next: (response) => {
+          state.set("setRefreshStampedToken", (prev) => ({
+            authState: prev.authState.type === AuthStateType.LOGGED_IN ? { ...prev.authState, token: response.token } : prev.authState
+          })), storageArea?.setItem(storageKey, JSON.stringify({ token: response.token }));
+        },
+        error: (error) => {
+          state.set("setRefreshStampedTokenError", { authState: { type: AuthStateType.ERROR, error } });
+        }
+      });
+    };
+  }
+), subscribeToStateAndFetchCurrentUser = createInternalAction(
+  ({ state }) => {
+    const { clientFactory, apiHost } = state.get().options, currentUser$ = state.observable.pipe(
+      rxjs.map(({ authState }) => authState),
+      rxjs.filter(
+        (authState) => authState.type === AuthStateType.LOGGED_IN && !authState.currentUser
+      ),
+      rxjs.map((authState) => authState.token),
+      rxjs.distinctUntilChanged()
+    ).pipe(
+      rxjs.map(
+        (token) => clientFactory({
+          apiVersion: DEFAULT_API_VERSION$1,
+          requestTagPrefix: REQUEST_TAG_PREFIX,
+          token,
+          ignoreBrowserTokenWarning: !0,
+          useProjectHostname: !1,
+          ...apiHost && { apiHost }
+        })
+      ),
+      rxjs.switchMap(
+        (client2) => client2.observable.request({ uri: "/users/me", method: "GET" })
+      )
+    );
+    return function() {
+      return currentUser$.subscribe({
+        next: (currentUser) => {
+          state.set("setCurrentUser", (prev) => ({
+            authState: prev.authState.type === AuthStateType.LOGGED_IN ? { ...prev.authState, currentUser } : prev.authState
+          }));
+        },
+        error: (error) => {
+          state.set("setError", { authState: { type: AuthStateType.ERROR, error } });
+        }
+      });
+    };
+  }
+);
+function getAuthCode(callbackUrl, locationHref) {
+  const loc = new URL(locationHref, DEFAULT_BASE), callbackLocation = callbackUrl ? new URL(callbackUrl, DEFAULT_BASE) : void 0, callbackLocationMatches = callbackLocation ? loc.pathname.toLowerCase().startsWith(callbackLocation.pathname.toLowerCase()) : !0, authCode = new URLSearchParams(loc.hash.slice(1)).get(AUTH_CODE_PARAM) || new URLSearchParams(loc.search).get(AUTH_CODE_PARAM);
+  return authCode && callbackLocationMatches ? authCode : null;
+}
+function getTokenFromStorage(storageArea, storageKey) {
+  if (!storageArea) return null;
+  const item = storageArea.getItem(storageKey);
+  if (item === null) return null;
+  try {
+    const parsed = JSON.parse(item);
+    if (typeof parsed != "object" || parsed === null || !("token" in parsed) || typeof parsed.token != "string")
+      throw new Error("Invalid stored auth data structure");
+    return parsed.token;
+  } catch {
+    return storageArea.removeItem(storageKey), null;
+  }
+}
+function getStorageEvents() {
+  return typeof window < "u" && typeof window.addEventListener == "function" ? rxjs.fromEvent(window, "storage") : rxjs.EMPTY;
+}
+function getDefaultStorage() {
+  try {
+    return typeof localStorage < "u" && typeof localStorage.getItem == "function" ? localStorage : void 0;
+  } catch {
+    return;
+  }
+}
+function getDefaultLocation() {
+  try {
+    return typeof location > "u" ? DEFAULT_BASE : typeof location.href == "string" ? location.href : DEFAULT_BASE;
+  } catch {
+    return DEFAULT_BASE;
+  }
+}
+const subscribeToStorageEventsAndSetToken = createInternalAction(
+  ({ state }) => {
+    const { storageArea, storageKey } = state.get().options, tokenFromStorage$ = rxjs.defer(getStorageEvents).pipe(
+      rxjs.filter(
+        (e3) => e3.storageArea === storageArea && e3.key === storageKey
+      ),
+      rxjs.map(() => getTokenFromStorage(storageArea, storageKey)),
+      rxjs.distinctUntilChanged()
+    );
+    return function() {
+      return tokenFromStorage$.subscribe((token) => {
+        state.set("updateTokenFromStorageEvent", {
+          authState: token ? { type: AuthStateType.LOGGED_IN, token, currentUser: null } : { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
+        });
+      });
+    };
+  }
+);
+let tokenRefresherRunning = !1;
+const authStore = {
+  name: "Auth",
+  getInitialState(instance) {
+    const {
+      apiHost,
+      callbackUrl,
+      providers: customProviders,
+      token: providedToken,
+      clientFactory = client.createClient,
+      initialLocationHref = getDefaultLocation(),
+      storageArea = getDefaultStorage()
+    } = instance.config.auth ?? {}, storageKey = "__sanity_auth_token";
+    let authState;
+    const token = getTokenFromStorage(storageArea, storageKey);
+    return providedToken ? authState = { type: AuthStateType.LOGGED_IN, token: providedToken, currentUser: null } : getAuthCode(callbackUrl, initialLocationHref) ? authState = { type: AuthStateType.LOGGING_IN, isExchangingToken: !1 } : token ? authState = { type: AuthStateType.LOGGED_IN, token, currentUser: null } : authState = { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }, {
+      authState,
+      options: {
+        apiHost,
+        callbackUrl,
+        customProviders,
+        providedToken,
+        clientFactory,
+        initialLocationHref,
+        storageKey,
+        storageArea
+      }
+    };
+  },
+  initialize() {
+    const stateSubscription = subscribeToStateAndFetchCurrentUser(this);
+    let storageEventsSubscription;
+    this.state.get().options?.storageArea && (storageEventsSubscription = subscribeToStorageEventsAndSetToken(this));
+    let refreshStampedTokenSubscription;
+    return tokenRefresherRunning || (tokenRefresherRunning = !0, refreshStampedTokenSubscription = refreshStampedToken(this)), () => {
+      stateSubscription.unsubscribe(), storageEventsSubscription?.unsubscribe(), refreshStampedTokenSubscription?.unsubscribe();
+    };
+  }
+}, getCurrentUserState = createStateSourceAction(
+  authStore,
+  ({ authState }) => authState.type === AuthStateType.LOGGED_IN ? authState.currentUser : null
+), getTokenState = createStateSourceAction(
+  authStore,
+  ({ authState }) => authState.type === AuthStateType.LOGGED_IN ? authState.token : null
+), getLoginUrlsState = createStateSourceAction(
+  authStore,
+  ({ providers }) => providers ?? null
+), getAuthState = createStateSourceAction(authStore, ({ authState }) => authState), getDashboardOrganizationId = createStateSourceAction(
+  authStore,
+  ({ dashboardContext }) => dashboardContext?.orgId
+), fetchLoginUrls = createAction(authStore, ({ state }) => {
+  const { callbackUrl, clientFactory, apiHost, customProviders } = state.get().options, client2 = clientFactory({
+    apiVersion: DEFAULT_API_VERSION$1,
+    requestTagPrefix: REQUEST_TAG_PREFIX,
+    useProjectHostname: !1,
+    ...apiHost && { apiHost }
+  });
+  return async function() {
+    const cachedProviders = state.get().providers;
+    if (cachedProviders) return cachedProviders;
+    const { providers: defaultProviders } = await client2.request({
+      uri: "/auth/providers",
+      tag: "fetch-providers"
+    });
+    let providers;
+    if (typeof customProviders == "function")
+      providers = await customProviders(defaultProviders);
+    else if (!customProviders?.length)
+      providers = defaultProviders;
+    else {
+      const customProviderUrls = new Set(customProviders.map((p2) => p2.url));
+      providers = defaultProviders.filter((official) => !customProviderUrls.has(official.url)).concat(customProviders);
+    }
+    const configuredProviders = providers.map((provider) => {
+      const url = new URL(provider.url), origin = new URL(
+        callbackUrl ? new URL(callbackUrl, new URL(getDefaultLocation()).origin).toString() : getDefaultLocation()
+      ), hashParams = new URLSearchParams(origin.hash.slice(1));
+      return hashParams.delete("sid"), origin.hash = hashParams.toString(), origin.searchParams.delete("sid"), origin.searchParams.delete("url"), origin.searchParams.delete("error"), url.searchParams.set("origin", origin.toString()), url.searchParams.set("withSid", "true"), url.searchParams.set("type", "stampedToken"), { ...provider, url: url.toString() };
+    });
+    return state.set("fetchedLoginUrls", { providers: configuredProviders }), configuredProviders;
+  };
+}), handleAuthCallback = createAction(authStore, ({ state }) => {
+  const { providedToken, callbackUrl, clientFactory, apiHost, storageArea, storageKey } = state.get().options;
+  return async function(locationHref = getDefaultLocation()) {
+    if (providedToken) return !1;
+    const { authState } = state.get();
+    if (authState.type === AuthStateType.LOGGING_IN && authState.isExchangingToken) return !1;
+    const authCode = getAuthCode(callbackUrl, locationHref);
+    if (!authCode) return !1;
+    const parsedUrl = new URL(locationHref);
+    let dashboardContext = {};
+    try {
+      const contextParam = parsedUrl.searchParams.get("_context") ?? "{}";
+      dashboardContext = JSON.parse(contextParam);
+    } catch (err) {
+      console.error("Failed to parse dashboard context:", err);
+    }
+    const { mode, env, orgId } = dashboardContext;
+    state.set("exchangeSessionForToken", {
+      authState: { type: AuthStateType.LOGGING_IN, isExchangingToken: !0 },
+      dashboardContext: { mode, env, orgId }
+    });
+    try {
+      const client2 = clientFactory({
+        apiVersion: DEFAULT_API_VERSION$1,
+        requestTagPrefix: REQUEST_TAG_PREFIX,
+        useProjectHostname: !1,
+        ...apiHost && { apiHost }
+      }), { token } = await client2.request({
+        method: "GET",
+        uri: "/auth/fetch",
+        query: { sid: authCode },
+        tag: "fetch-token"
+      });
+      storageArea?.setItem(storageKey, JSON.stringify({ token })), state.set("setToken", { authState: { type: AuthStateType.LOGGED_IN, token, currentUser: null } });
+      const loc = new URL(locationHref);
+      return loc.hash = "", loc.searchParams.delete("sid"), loc.searchParams.delete("url"), loc.toString();
+    } catch (error) {
+      return state.set("exchangeSessionForTokenError", { authState: { type: AuthStateType.ERROR, error } }), !1;
+    }
+  };
+}), logout = createAction(authStore, ({ state }) => {
+  const { clientFactory, apiHost, providedToken, storageArea, storageKey } = state.get().options;
+  return async function() {
+    if (providedToken) return;
+    const { authState } = state.get();
+    if (authState.type === AuthStateType.LOGGED_OUT && authState.isDestroyingSession) return;
+    const token = authState.type === AuthStateType.LOGGED_IN && authState.token;
+    try {
+      token && (state.set("loggingOut", {
+        authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !0 }
+      }), await clientFactory({
+        token,
+        requestTagPrefix: REQUEST_TAG_PREFIX,
+        apiVersion: DEFAULT_API_VERSION$1,
+        ...apiHost && { apiHost },
+        useProjectHostname: !1
+      }).request({ uri: "/auth/logout", method: "POST" }));
+    } finally {
+      state.set("logoutSuccess", {
+        authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
+      }), storageArea?.removeItem(storageKey);
+    }
+  };
+});
+function getResourceId(documentResourceId) {
+  if (documentResourceId)
+    return documentResourceId.split(":")[1];
+}
+function parseBracketContent(content) {
+  const rangeMatch = content.match(/^(\d*):(\d*)$/);
+  if (rangeMatch) {
+    const startStr = rangeMatch[1], endStr = rangeMatch[2], start = startStr === "" ? "" : parseInt(startStr, 10), end = endStr === "" ? "" : parseInt(endStr, 10);
+    return [start, end];
+  }
+  const keyedMatch = content.match(/^_key==["'](.+)["']$/);
+  if (keyedMatch)
+    return { _key: keyedMatch[1] };
+  const index = parseInt(content, 10);
+  if (!isNaN(index))
+    return index;
+  throw new Error(`Invalid bracket content: \u201C[${content}]\u201D`);
+}
+function parseSegment(segment) {
+  const segments = [];
+  let idx = 0;
+  function pushIfNotEmpty(text) {
+    text && segments.push(text);
+  }
+  for (; idx < segment.length; ) {
+    const openIndex = segment.indexOf("[", idx);
+    if (openIndex === -1) {
+      const remaining = segment.slice(idx);
+      pushIfNotEmpty(remaining);
+      break;
+    }
+    const before = segment.slice(idx, openIndex);
+    pushIfNotEmpty(before);
+    const closeIndex = segment.indexOf("]", openIndex);
+    if (closeIndex === -1)
+      throw new Error(`Unmatched "[" in segment: "${segment}"`);
+    const bracketContent = segment.slice(openIndex + 1, closeIndex);
+    segments.push(parseBracketContent(bracketContent)), idx = closeIndex + 1;
+  }
+  return segments;
+}
+function parsePath(path) {
+  const result = [];
+  let buffer = "", bracketDepth = 0;
+  for (let i2 = 0; i2 < path.length; i2++) {
+    const ch = path[i2];
+    ch === "[" ? (bracketDepth++, buffer += ch) : ch === "]" ? (bracketDepth--, buffer += ch) : ch === "." && bracketDepth === 0 ? buffer && (result.push(...parseSegment(buffer)), buffer = "") : buffer += ch;
+  }
+  return buffer && result.push(...parseSegment(buffer)), result;
+}
+function stringifyPath(path) {
+  let result = "";
+  for (let i2 = 0; i2 < path.length; i2++) {
+    const segment = path[i2];
+    if (typeof segment == "string")
+      result && (result += "."), result += segment;
+    else if (typeof segment == "number")
+      result += `[${segment}]`;
+    else if (Array.isArray(segment)) {
+      const [start, end] = segment, startStr = start === "" ? "" : String(start), endStr = end === "" ? "" : String(end);
+      result += `[${startStr}:${endStr}]`;
+    } else
+      result += `[_key=="${segment._key}"]`;
+  }
+  return result;
+}
+function jsonMatch(input, pathExpression) {
+  return matchRecursive(input, parsePath(pathExpression), []);
+}
+function matchRecursive(value, path, currentPath) {
+  if (path.length === 0)
+    return [{ value, path: currentPath }];
+  const [head, ...rest] = path;
+  if (typeof head == "string") {
+    if (value && typeof value == "object" && !Array.isArray(value)) {
+      const nextValue = value[head];
+      return matchRecursive(nextValue, rest, [...currentPath, head]);
+    }
+    return [];
+  }
+  if (typeof head == "number") {
+    if (Array.isArray(value)) {
+      const nextValue = value.at(head);
+      return matchRecursive(nextValue, rest, [...currentPath, head]);
+    }
+    return [];
+  }
+  if (Array.isArray(head)) {
+    if (!Array.isArray(value))
+      return [];
+    const [start, end] = head, startIndex = start === "" ? 0 : start, endIndex = end === "" ? value.length : end;
+    let results = [];
+    for (let i2 = startIndex; i2 < endIndex; i2++)
+      results = results.concat(matchRecursive(value[i2], rest, [...currentPath, i2]));
+    return results;
+  }
+  const arrIndex = getIndexForKey(value, head._key);
+  if (arrIndex === void 0 || !Array.isArray(value))
+    return [];
+  const nextVal = value[arrIndex];
+  return matchRecursive(nextVal, rest, [...currentPath, arrIndex]);
+}
+function generateArrayKey(length = 12) {
+  const numBytes = Math.ceil(length / 2), bytes = crypto.getRandomValues(new Uint8Array(numBytes));
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, length);
+}
+function memoize(fn) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return (input) => {
+    if (!input || typeof input != "object") return fn(input);
+    const cached = cache.get(input);
+    if (cached) return cached;
+    const result = fn(input);
+    return cache.set(input, result), result;
+  };
+}
+const ensureArrayKeysDeep = memoize((input) => {
+  if (!input || typeof input != "object") return input;
+  if (Array.isArray(input))
+    return !input.length || typeof input[0] != "object" || input.every(types.isKeyedObject) ? input : input.map((item) => !item || typeof item != "object" ? item : types.isKeyedObject(item) ? ensureArrayKeysDeep(item) : { ...ensureArrayKeysDeep(item), _key: generateArrayKey() });
+  const entries = Object.entries(input).map(([key, value]) => [key, ensureArrayKeysDeep(value)]);
+  return entries.every(([key, value]) => input[key] === value) ? input : Object.fromEntries(entries);
+});
+function set(input, pathExpressionValues) {
+  const result = Object.entries(pathExpressionValues).flatMap(
+    ([pathExpression, replacementValue]) => jsonMatch(input, pathExpression).map((matchEntry) => ({
+      ...matchEntry,
+      replacementValue
+    }))
+  ).reduce((acc, { path, replacementValue }) => setDeep(acc, path, replacementValue), input);
+  return ensureArrayKeysDeep(result);
+}
+function setIfMissing(input, pathExpressionValues) {
+  const result = Object.entries(pathExpressionValues).flatMap(([pathExpression, replacementValue]) => jsonMatch(input, pathExpression).map((matchEntry) => ({
+    ...matchEntry,
+    replacementValue
+  }))).filter((matchEntry) => matchEntry.value === null || matchEntry.value === void 0).reduce((acc, { path, replacementValue }) => setDeep(acc, path, replacementValue), input);
+  return ensureArrayKeysDeep(result);
+}
+function unset(input, pathExpressions) {
+  const result = pathExpressions.flatMap((pathExpression) => jsonMatch(input, pathExpression)).reduce((acc, { path }) => unsetDeep(acc, path), input);
+  return ensureArrayKeysDeep(result);
+}
+const operations = ["before", "after", "replace"];
+function insert(input, insertPatch) {
+  const operation = operations.find((op) => op in insertPatch);
+  if (!operation) return input;
+  const { items } = insertPatch, pathExpression = insertPatch[operation];
+  if (typeof pathExpression != "string") return input;
+  function normalizeIndex(index, parentLength) {
+    switch (operation) {
+      case "before":
+        return index < 0 ? parentLength : index;
+      case "after":
+        return index < 0 ? -1 : index;
+      default:
+        return index < 0 ? parentLength + index : index;
+    }
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  jsonMatch(input, pathExpression).map(({ path }) => {
+    const segment = path[path.length - 1];
+    let index;
+    if (types.isKeySegment(segment) ? index = getIndexForKey(input, segment._key) : typeof segment == "number" && (index = segment), typeof index != "number") return null;
+    const parentPath = path.slice(0, path.length - 1), parent = getDeep(input, parentPath);
+    if (!Array.isArray(parent)) return null;
+    const normalizedIndex = normalizeIndex(index, parent.length);
+    return { parent, parentPath, normalizedIndex };
+  }).filter(isNonNullable).forEach(({ parent, parentPath, normalizedIndex }) => {
+    grouped.has(parent) ? grouped.get(parent).indexes.push(normalizedIndex) : grouped.set(parent, { array: parent, pathToArray: parentPath, indexes: [normalizedIndex] });
+  });
+  const result = Array.from(grouped.values()).map((entry) => ({
+    ...entry,
+    indexes: entry.indexes.sort((a2, b2) => a2 - b2)
+  })).reduce((acc, { array, indexes, pathToArray }) => {
+    switch (operation) {
+      case "before": {
+        const firstIndex = indexes[0];
+        return setDeep(acc, pathToArray, [
+          ...array.slice(0, firstIndex),
+          ...items,
+          ...array.slice(firstIndex)
+        ]);
+      }
+      case "after": {
+        const lastIndex = indexes[indexes.length - 1] + 1;
+        return setDeep(acc, pathToArray, [
+          ...array.slice(0, lastIndex),
+          ...items,
+          ...array.slice(lastIndex)
+        ]);
+      }
+      // default to 'replace' behavior
+      default: {
+        const firstIndex = indexes[0], indexSet = new Set(indexes);
+        return setDeep(acc, pathToArray, [
+          ...array.slice(0, firstIndex),
+          ...items,
+          ...array.slice(firstIndex).filter((_2, idx) => !indexSet.has(idx + firstIndex))
+        ]);
+      }
+    }
+  }, input);
+  return ensureArrayKeysDeep(result);
+}
+function inc(input, pathExpressionValues) {
+  const result = Object.entries(pathExpressionValues).flatMap(
+    ([pathExpression, valueToAdd]) => jsonMatch(input, pathExpression).map((matchEntry) => ({
+      ...matchEntry,
+      valueToAdd
+    }))
+  ).filter(
+    (matchEntry) => typeof matchEntry.value == "number"
+  ).reduce((acc, { path, value, valueToAdd }) => setDeep(acc, path, value + valueToAdd), input);
+  return ensureArrayKeysDeep(result);
+}
+function dec(input, pathExpressionValues) {
+  const result = inc(
+    input,
+    Object.fromEntries(
+      Object.entries(pathExpressionValues).filter(([, value]) => typeof value == "number").map(([key, value]) => [key, -value])
+    )
+  );
+  return ensureArrayKeysDeep(result);
+}
+function diffMatchPatch(input, pathExpressionValues) {
+  const result = Object.entries(pathExpressionValues).flatMap(([pathExpression, dmp]) => jsonMatch(input, pathExpression).map((m2) => ({ ...m2, dmp }))).filter((i2) => i2.value !== void 0).map(({ path, value, dmp }) => {
+    if (typeof value != "string")
+      throw new Error(
+        `Can't diff-match-patch \`${JSON.stringify(value)}\` at path \`${stringifyPath(path)}\`, because it is not a string`
+      );
+    const [nextValue] = diffMatchPatch$1.applyPatches(diffMatchPatch$1.parsePatch(dmp), value);
+    return { path, value: nextValue };
+  }).reduce((acc, { path, value }) => setDeep(acc, path, value), input);
+  return ensureArrayKeysDeep(result);
+}
+function ifRevisionID(input, revisionId) {
+  const inputRev = typeof input == "object" && input && "_rev" in input && typeof input._rev == "string" ? input._rev : void 0;
+  if (typeof inputRev != "string")
+    throw new Error("Patch specified `ifRevisionID` but could not find document's revision ID.");
+  if (revisionId !== inputRev)
+    throw new Error(
+      `Patch's \`ifRevisionID\` \`${revisionId}\` does not match document's revision ID \`${inputRev}\``
+    );
+  return input;
+}
+function isNonNullable(t2) {
+  return t2 != null;
+}
+const indexCache = /* @__PURE__ */ new WeakMap();
+function getIndexForKey(input, key) {
+  if (!Array.isArray(input)) return;
+  const cached = indexCache.get(input);
+  if (cached) return cached[key];
+  const lookup = input.reduce((acc, next, index) => (typeof next?._key == "string" && (acc[next._key] = index), acc), {});
+  return indexCache.set(input, lookup), lookup[key];
+}
+function getDeep(input, path) {
+  const [currentSegment, ...restOfPath] = path;
+  if (currentSegment === void 0) return input;
+  if (typeof input != "object" || input === null) return;
+  let key;
+  if (types.isKeySegment(currentSegment) ? key = getIndexForKey(input, currentSegment._key) : (typeof currentSegment == "string" || typeof currentSegment == "number") && (key = currentSegment), key === void 0) return;
+  const nestedInput = typeof key == "number" && Array.isArray(input) ? input.at(key) : input[key];
+  return getDeep(nestedInput, restOfPath);
+}
+function setDeep(input, path, value) {
+  const [currentSegment, ...restOfPath] = path;
+  if (currentSegment === void 0) return value;
+  if (typeof input != "object" || input === null) {
+    if (typeof currentSegment == "string")
+      return { [currentSegment]: setDeep(null, restOfPath, value) };
+    let index;
+    if (types.isKeySegment(currentSegment))
+      index = 0;
+    else if (typeof currentSegment == "number" && currentSegment >= 0)
+      index = currentSegment;
+    else
+      return input;
+    return [
+      // fill until index
+      ...Array.from({ length: index }).fill(null),
+      // then set deep here
+      setDeep(null, restOfPath, value)
+    ];
+  }
+  if (Array.isArray(input)) {
+    let index;
+    return types.isKeySegment(currentSegment) ? index = getIndexForKey(input, currentSegment._key) : typeof currentSegment == "number" && (index = currentSegment < 0 ? input.length + currentSegment : currentSegment), index === void 0 ? input : index in input ? input.map(
+      (nestedInput, i2) => i2 === index ? setDeep(nestedInput, restOfPath, value) : nestedInput
+    ) : [
+      ...input,
+      ...Array.from({ length: index - input.length }).fill(null),
+      setDeep(null, restOfPath, value)
+    ];
+  }
+  return typeof currentSegment == "object" ? input : currentSegment in input ? Object.fromEntries(
+    Object.entries(input).map(
+      ([key, nestedInput]) => key === currentSegment ? [key, setDeep(nestedInput, restOfPath, value)] : [key, nestedInput]
+    )
+  ) : { ...input, [currentSegment]: setDeep(null, restOfPath, value) };
+}
+function unsetDeep(input, path) {
+  const [currentSegment, ...restOfPath] = path;
+  if (currentSegment === void 0 || typeof input != "object" || input === null) return input;
+  let _segment;
+  if (types.isKeySegment(currentSegment) ? _segment = getIndexForKey(input, currentSegment._key) : (typeof currentSegment == "string" || typeof currentSegment == "number") && (_segment = currentSegment), _segment === void 0) return input;
+  let segment = _segment;
+  return typeof segment == "number" && Array.isArray(input) && (segment = segment < 0 ? input.length + segment : segment), segment in input ? restOfPath.length ? Array.isArray(input) ? input.map(
+    (nestedInput, index) => index === segment ? unsetDeep(nestedInput, restOfPath) : nestedInput
+  ) : Object.fromEntries(
+    Object.entries(input).map(
+      ([key, value]) => key === segment ? [key, unsetDeep(value, restOfPath)] : [key, value]
+    )
+  ) : Array.isArray(input) ? input.filter((_nestedInput, index) => index !== segment) : Object.fromEntries(Object.entries(input).filter(([key]) => key !== segment.toString())) : input;
+}
+const DEFAULT_API_VERSION = "2024-11-12", DEFAULT_REQUEST_TAG_PREFIX = "sanity.sdk", clientStore = {
+  name: "clientStore",
+  getInitialState: (instance) => {
+    const { identity, config } = instance, defaultClient = client.createClient({
+      projectId: identity.projectId,
+      dataset: identity.dataset,
+      token: config?.auth?.token,
+      useCdn: !1,
+      apiVersion: DEFAULT_API_VERSION,
+      requestTagPrefix: DEFAULT_REQUEST_TAG_PREFIX,
+      ...config?.auth?.apiHost ? { apiHost: config.auth.apiHost } : {}
+    }), defaultGlobalClient = client.createClient({
+      token: config?.auth?.token,
+      useCdn: !1,
+      apiVersion: "vX",
+      // Many global APIs are only available under this version, we may need to support other versions in the future
+      useProjectHostname: !1,
+      requestTagPrefix: DEFAULT_REQUEST_TAG_PREFIX,
+      ...config?.auth?.apiHost ? { apiHost: config.auth.apiHost } : {}
+    });
+    return {
+      defaultClient,
+      defaultGlobalClient
+    };
+  },
+  initialize() {
+    const authEventSubscription = subscribeToAuthEvents(this);
+    return () => {
+      authEventSubscription.unsubscribe();
+    };
+  }
+}, receiveToken = (prev, token) => {
+  const newDefaultClient = prev.defaultClient.withConfig({
+    token
+  }), newGlobalClient = prev.defaultGlobalClient.withConfig({
+    token
+  });
+  return {
+    defaultClient: newDefaultClient,
+    defaultGlobalClient: newGlobalClient
+  };
+}, subscribeToAuthEvents = createInternalAction(
+  ({ instance, state }) => () => getTokenState(instance).observable.subscribe((newToken) => {
+    state.set("receiveToken", (prev) => receiveToken(prev, newToken ?? void 0));
+  })
+), optionsCache = /* @__PURE__ */ new WeakMap(), defaultClientSelector = (state, options) => options?.scope === "global" ? state.defaultGlobalClient : state.defaultClient, memoizedOptionsSelector = reselect.createSelector(
+  [defaultClientSelector, (_state, options) => options],
+  (client2, options) => {
+    let nestedCache = optionsCache.get(client2);
+    nestedCache || (nestedCache = /* @__PURE__ */ new Map(), optionsCache.set(client2, nestedCache));
+    const key = JSON.stringify(options);
+    return nestedCache.get(key) || (nestedCache.set(key, options), options);
+  }
+), clientSelector = reselect.createSelector(
+  [defaultClientSelector, memoizedOptionsSelector],
+  (client2, options) => client2.withConfig(options)
+), getClient = createAction(
+  clientStore,
+  ({ state }) => (options) => clientSelector(state.get(), options)
+), getClientState = createStateSourceAction(clientStore, clientSelector), comlinkControllerStore = {
+  name: "connectionStore",
+  getInitialState: () => ({
+    controller: null,
+    controllerOrigin: null,
+    channels: /* @__PURE__ */ new Map()
+  }),
+  initialize() {
+    return () => {
+      destroyController(this);
+    };
+  }
+}, destroyController = createInternalAction(
+  ({ state }) => () => {
+    const { controller } = state.get();
+    controller && (controller.destroy(), state.set("destroyController", {
+      controller: null,
+      channels: /* @__PURE__ */ new Map()
+    }));
+  }
+), getOrCreateChannel = createAction(comlinkControllerStore, ({ state }) => (options) => {
+  const controller = state.get().controller;
+  if (!controller)
+    throw new Error("Controller must be initialized before using or creating channels");
+  const channels = state.get().channels, existing = channels.get(options.name);
+  if (existing) {
+    if (!lodashEs.isEqual(existing.options, options))
+      throw new Error(`Channel "${options.name}" already exists with different options`);
+    return state.set("incrementChannelRefCount", {
+      channels: new Map(channels).set(options.name, {
+        ...existing,
+        refCount: existing.refCount + 1
+      })
+    }), existing.channel.start(), existing.channel;
+  }
+  const channel = controller.createChannel(options);
+  return channel.start(), state.set("createChannel", {
+    channels: new Map(channels).set(options.name, {
+      channel,
+      options,
+      refCount: 1
+    })
+  }), channel;
+}), getOrCreateController = createAction(comlinkControllerStore, ({ state, instance }) => (targetOrigin) => {
+  const { controller, controllerOrigin } = state.get();
+  if (controller && controllerOrigin === targetOrigin)
+    return controller;
+  controller && destroyController({ state, instance });
+  const newController = comlink.createController({ targetOrigin });
+  return state.set("initializeController", {
+    controllerOrigin: targetOrigin,
+    controller: newController
+  }), newController;
+}), releaseChannel = createAction(comlinkControllerStore, ({ state }) => (name) => {
+  const channels = state.get().channels, channelEntry = channels.get(name);
+  if (channelEntry) {
+    const newRefCount = channelEntry.refCount === 0 ? 0 : channelEntry.refCount - 1;
+    newRefCount === 0 ? (channelEntry.channel.stop(), channels.delete(name), state.set("releaseChannel", { channels: new Map(channels) })) : state.set("releaseChannel", {
+      channels: new Map(channels).set(name, {
+        ...channelEntry,
+        refCount: newRefCount
+      })
+    });
+  }
+}), comlinkNodeStore = {
+  name: "nodeStore",
+  getInitialState: () => ({
+    nodes: /* @__PURE__ */ new Map()
+  }),
+  initialize() {
+    return () => {
+      this.state.get().nodes.forEach(({ node }) => {
+        node.stop();
+      });
+    };
+  }
+}, getOrCreateNode = createAction(comlinkNodeStore, ({ state }) => (options) => {
+  const nodes = state.get().nodes, existing = nodes.get(options.name);
+  if (existing) {
+    if (!lodashEs.isEqual(existing.options, options))
+      throw new Error(`Node "${options.name}" already exists with different options`);
+    return state.set("incrementNodeRefCount", {
+      nodes: new Map(nodes).set(options.name, {
+        ...existing,
+        refCount: existing.refCount + 1
+      })
+    }), existing.node.start(), existing.node;
+  }
+  const node = comlink.createNode(options);
+  return node.start(), nodes.set(options.name, { node, options, refCount: 1 }), state.set("createNode", { nodes }), node;
+}), releaseNode = createAction(comlinkNodeStore, ({ state }) => (name) => {
+  const nodes = state.get().nodes, nodeEntry = nodes.get(name);
+  if (nodeEntry) {
+    const newRefCount = nodeEntry.refCount === 0 ? 0 : nodeEntry.refCount - 1;
+    newRefCount === 0 ? (nodeEntry.node.stop(), nodes.delete(name), state.set("releaseNode", { nodes: new Map(nodes) })) : state.set("releaseNode", {
+      nodes: new Map(nodes).set(name, {
+        ...nodeEntry,
+        refCount: newRefCount
+      })
+    });
+  }
+});
+function getPublishedId(id) {
+  const draftsPrefix = "drafts.";
+  return id.startsWith(draftsPrefix) ? id.slice(draftsPrefix.length) : id;
+}
+function getDraftId(id) {
+  const draftsPrefix = "drafts.";
+  return id.startsWith(draftsPrefix) ? id : `${draftsPrefix}${id}`;
+}
+function insecureRandomId() {
+  return Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+}
+function createFetcherStore({
+  name,
+  fetcher: getObservable,
+  getKey,
+  fetchThrottleInternal = 1e3,
+  stateExpirationDelay = 5e3
+}) {
+  const store = {
+    name,
+    getInitialState: () => ({
+      stateByParams: {}
+    }),
+    initialize() {
+      const subscription = subscribeToSubscriptionsAndFetch(this);
+      return () => subscription.unsubscribe();
+    }
+  }, subscribeToSubscriptionsAndFetch = createInternalAction(
+    ({ instance, state }) => function() {
+      const factoryFn = getObservable(instance);
+      return state.observable.pipe(
+        // Map the state to an array of [serialized, entry] pairs.
+        operators.switchMap((s2) => {
+          const entries = Object.entries(s2.stateByParams);
+          return entries.length > 0 ? rxjs.from(entries) : rxjs.EMPTY;
+        }),
+        // Group by the serialized key.
+        operators.groupBy(([key]) => key),
+        operators.mergeMap(
+          (group$) => group$.pipe(
+            // Emit an initial value for pairwise comparisons.
+            operators.startWith([
+              group$.key,
+              void 0
+            ]),
+            operators.pairwise(),
+            // Trigger only when the subscriptions array grows.
+            operators.filter(([[, prevEntry], [, currEntry]]) => {
+              const prevSubs = prevEntry?.subscriptions ?? [];
+              return (currEntry?.subscriptions ?? []).length > prevSubs.length;
+            }),
+            operators.map(([, [, currEntry]]) => currEntry),
+            // Only trigger if we haven't fetched recently.
+            operators.filter((entry) => {
+              const lastFetch = entry?.lastFetchInitiatedAt;
+              return lastFetch ? Date.now() - new Date(lastFetch).getTime() >= fetchThrottleInternal : !0;
+            }),
+            operators.switchMap((entry) => entry ? (state.set(
+              "setLastFetchInitiatedAt",
+              (prev) => ({
+                stateByParams: {
+                  ...prev.stateByParams,
+                  [entry.key]: {
+                    ...entry,
+                    ...prev.stateByParams[entry.key],
+                    lastFetchInitiatedAt: (/* @__PURE__ */ new Date()).toISOString()
+                  }
+                }
+              })
+            ), factoryFn(...entry.params).pipe(
+              // the `createStateSourceAction` util requires the update
+              // to
+              operators.delay(0, rxjs.asapScheduler),
+              operators.tap(
+                (data) => state.set("setData", (prev) => ({
+                  stateByParams: {
+                    ...prev.stateByParams,
+                    [entry.key]: {
+                      ...lodashEs.omit(entry, "error"),
+                      ...lodashEs.omit(prev.stateByParams[entry.key], "error"),
+                      data
+                    }
+                  }
+                }))
+              ),
+              operators.catchError((error) => (state.set("setError", (prev) => ({
+                stateByParams: {
+                  ...prev.stateByParams,
+                  [entry.key]: {
+                    ...entry,
+                    ...prev.stateByParams[entry.key],
+                    error
+                  }
+                }
+              })), rxjs.EMPTY))
+            )) : rxjs.EMPTY)
+          )
+        )
+      ).subscribe({
+        error: (error) => state.set("setError", { error })
+      });
+    }
+  ), getState2 = createStateSourceAction(store, {
+    selector: ({ stateByParams, error }, ...params) => {
+      if (error) throw error;
+      const key = getKey(...params), entry = stateByParams[key];
+      if (entry?.error) throw entry.error;
+      return entry?.data;
+    },
+    onSubscribe: ({ state }, ...params) => {
+      const subscriptionId = insecureRandomId(), key = getKey(...params);
+      return state.set("addSubscription", (prev) => ({
+        stateByParams: {
+          ...prev.stateByParams,
+          [key]: {
+            ...prev.stateByParams[key],
+            key,
+            params: prev.stateByParams[key]?.params || params,
+            subscriptions: [...prev.stateByParams[key]?.subscriptions || [], subscriptionId]
+          }
+        }
+      })), () => {
+        setTimeout(() => {
+          state.set("removeSubscription", (prev) => {
+            const entry = prev.stateByParams[key];
+            if (!entry) return prev;
+            const newSubs = (entry.subscriptions || []).filter((id) => id !== subscriptionId);
+            return newSubs.length === 0 ? { stateByParams: lodashEs.omit(prev.stateByParams, key) } : {
+              stateByParams: {
+                ...prev.stateByParams,
+                [key]: {
+                  ...entry,
+                  subscriptions: newSubs
+                }
+              }
+            };
+          });
+        }, stateExpirationDelay);
+      };
+    }
+  }), resolveState = createAction(store, () => function(...params) {
+    return rxjs.firstValueFrom(
+      getState2(this, ...params).observable.pipe(operators.first((i2) => i2 !== void 0))
+    );
+  });
+  return { getState: getState2, resolveState };
+}
+const datasets = createFetcherStore({
+  name: "Datasets",
+  getKey: () => "datasets",
+  fetcher: (instance) => () => getClientState(instance, { apiVersion: "vX", scope: "project" }).observable.pipe(
+    rxjs.switchMap((client2) => client2.observable.datasets.list())
+  )
+}), getDatasetsState = datasets.getState, resolveDatasets = datasets.resolveState, isSanityMutatePatch = (value) => !(typeof value != "object" || !value || !("type" in value) || typeof value.type != "string" || value.type !== "patch" || !("id" in value) || typeof value.id != "string" || !("patches" in value) || !Array.isArray(value.patches));
+function createDocument(doc) {
+  return {
+    type: "document.create",
+    ...doc._id && { documentId: doc._id },
+    documentType: doc._type,
+    ...doc.resourceId && { resourceId: doc.resourceId }
+  };
+}
+function deleteDocument(doc) {
+  return {
+    type: "document.delete",
+    documentId: getPublishedId(doc._id),
+    ...doc.resourceId && { resourceId: doc.resourceId }
+  };
+}
+function convertSanityMutatePatch(sanityPatchMutation) {
+  const encoded = mutate.SanityEncoder.encode(sanityPatchMutation);
+  return {
+    documentId: sanityPatchMutation.id,
+    type: "document.edit",
+    patches: encoded.map((i2) => {
+      const copy = { ...i2.patch };
+      return "id" in copy && delete copy.id, copy;
+    })
+  };
+}
+function editDocument(doc, patches) {
+  return isSanityMutatePatch(doc) ? convertSanityMutatePatch(doc) : {
+    type: "document.edit",
+    documentId: getPublishedId(doc._id),
+    ...patches && { patches: Array.isArray(patches) ? patches : [patches] },
+    ...doc.resourceId && { resourceId: doc.resourceId }
+  };
+}
+function publishDocument(doc) {
+  return {
+    type: "document.publish",
+    documentId: getPublishedId(doc._id),
+    ...doc.resourceId && { resourceId: doc.resourceId }
+  };
+}
+function unpublishDocument(doc) {
+  return {
+    type: "document.unpublish",
+    documentId: getPublishedId(doc._id),
+    ...doc.resourceId && { resourceId: doc.resourceId }
+  };
+}
+function discardDocument(doc) {
+  return {
+    type: "document.discard",
+    documentId: getPublishedId(doc._id),
+    ...doc.resourceId && { resourceId: doc.resourceId }
+  };
+}
+const DOCUMENT_STATE_CLEAR_DELAY = 1e3, INITIAL_OUTGOING_THROTTLE_TIME = 1e3, API_VERSION$2 = "vX", patchOperations = {
+  ifRevisionID,
+  set,
+  setIfMissing,
+  unset,
+  inc,
+  dec,
+  insert,
+  diffMatchPatch
+};
+function getId(id) {
+  return !id || typeof id != "string" ? crypto.randomUUID() : id.endsWith(".") ? `${id}${crypto.randomUUID()}` : id;
+}
+function getDocumentIds(selection) {
+  if ("id" in selection) {
+    const ids = (Array.isArray(selection.id) ? selection.id : [selection.id]).filter((id) => typeof id == "string");
+    return Array.from(new Set(ids));
+  }
+  if ("query" in selection)
+    throw new Error("'query' in mutations is not supported.");
+  return [];
+}
+function processMutations({
+  documents,
+  mutations,
+  transactionId,
+  timestamp
+}) {
+  if (!mutations.length) return documents;
+  const dataset = { ...documents }, now = timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  for (const mutation of mutations) {
+    if ("create" in mutation) {
+      const id = getId(mutation.create._id);
+      if (dataset[id])
+        throw new Error(
+          `Cannot create document with \`_id\` \`${id}\` because another document with the same ID already exists.`
+        );
+      const document2 = {
+        // > `_createdAt` and `_updatedAt` may be submitted and will override
+        // > the default which is of course the current time. This can be used
+        // > to reconstruct a data-set with its timestamp structure intact.
+        // >
+        // > [- source](https://www.sanity.io/docs/http-mutations#c732f27330a4)
+        _createdAt: now,
+        _updatedAt: now,
+        ...mutation.create,
+        // prefer the user's `_createdAt` and `_updatedAt`
+        _rev: transactionId,
+        _id: id
+      };
+      dataset[id] = document2;
+      continue;
+    }
+    if ("createOrReplace" in mutation) {
+      const id = getId(mutation.createOrReplace._id), prev = dataset[id], document2 = {
+        ...mutation.createOrReplace,
+        // otherwise, if the mutation provided, a `_createdAt` time, use it,
+        // otherwise default to now
+        _createdAt: (
+          // if there was an existing document, use the previous `_createdAt`
+          // since we're replacing the current document
+          prev?._createdAt || // if there was no previous document, then we're creating this
+          // document for the first time so we should use the `_createdAt` from
+          // the mutation if the user included it
+          typeof mutation.createOrReplace._createdAt == "string" && mutation.createOrReplace._createdAt || // otherwise, default to now
+          now
+        ),
+        _updatedAt: (
+          // if there was an existing document, then set the `_updatedAt` to now
+          // since we're replacing the current document
+          prev ? now : (
+            // otherwise, we're creating this document for the first time,
+            // in that case, use the user's `_updatedAt` if included in the
+            // mutation
+            typeof mutation.createOrReplace._updatedAt == "string" && mutation.createOrReplace._updatedAt || // otherwise default to now
+            now
+          )
+        ),
+        _rev: transactionId,
+        _id: id
+      };
+      dataset[id] = document2;
+      continue;
+    }
+    if ("createIfNotExists" in mutation) {
+      const id = getId(mutation.createIfNotExists._id);
+      if (dataset[id]) continue;
+      const document2 = {
+        // same logic as `create`:
+        // prefer the user's `_createdAt` and `_updatedAt`
+        _createdAt: now,
+        _updatedAt: now,
+        ...mutation.createIfNotExists,
+        _rev: transactionId,
+        _id: id
+      };
+      dataset[id] = document2;
+      continue;
+    }
+    if ("delete" in mutation) {
+      for (const id of getDocumentIds(mutation.delete))
+        dataset[id] = null;
+      continue;
+    }
+    if ("patch" in mutation) {
+      const { patch } = mutation, patched = getDocumentIds(patch).map((id) => {
+        if (!dataset[id])
+          throw new Error(`Cannot patch document with ID \`${id}\` because it was not found.`);
+        return Object.entries(patchOperations).reduce((acc, [type, operation]) => patch[type] ? operation(
+          acc,
+          // @ts-expect-error TS doesn't handle this union very well
+          patch[type]
+        ) : acc, dataset[id]);
+      });
+      for (const result of patched)
+        dataset[result._id] = {
+          ...result,
+          _rev: transactionId,
+          _updatedAt: now
+        };
+      continue;
+    }
+  }
+  return dataset;
+}
+const DEFAULT_MAX_BUFFER_SIZE = 20, DEFAULT_DEADLINE_MS = 3e4;
+class OutOfSyncError extends Error {
+  /**
+   * Attach state to the error for debugging/reporting
+   */
+  state;
+  constructor(message, state) {
+    super(message), this.name = "OutOfSyncError", this.state = state;
+  }
+}
+class DeadlineExceededError extends OutOfSyncError {
+  constructor(message, state) {
+    super(message, state), this.name = "DeadlineExceededError";
+  }
+}
+class MaxBufferExceededError extends OutOfSyncError {
+  constructor(message, state) {
+    super(message, state), this.name = "MaxBufferExceededError";
+  }
+}
+function sortListenerEvents(options) {
+  const { resolveChainDeadline = DEFAULT_DEADLINE_MS, maxBufferSize = DEFAULT_MAX_BUFFER_SIZE } = {};
+  return (input$) => input$.pipe(
+    // Maintain state: current base revision, a buffer of pending mutation events,
+    // and a list of events to emit.
+    operators.scan(
+      (state, event) => {
+        if (event.type === "sync")
+          return {
+            base: { revision: event.document?._rev },
+            buffer: [],
+            emitEvents: [event]
+          };
+        if (event.type === "mutation") {
+          if (!state.base)
+            throw new Error(
+              "Invalid state. Cannot process mutation event without a base sync event"
+            );
+          const buffer = state.buffer.concat(event), emitEvents = [];
+          let baseRevision = state.base.revision, progress = !0;
+          for (; progress; ) {
+            progress = !1;
+            const idx = buffer.findIndex((e3) => e3.previousRev === baseRevision);
+            if (idx !== -1) {
+              const [next] = buffer.splice(idx, 1);
+              emitEvents.push(next), baseRevision = next.transition === "disappear" ? void 0 : next.resultRev, progress = !0;
+            }
+          }
+          if (buffer.length >= maxBufferSize)
+            throw new MaxBufferExceededError(
+              `Too many unchainable mutation events (${buffer.length}) waiting to resolve.`,
+              { base: { revision: baseRevision }, buffer, emitEvents }
+            );
+          return {
+            base: { revision: baseRevision },
+            buffer,
+            emitEvents
+          };
+        }
+        return { ...state, emitEvents: [event] };
+      },
+      {
+        base: void 0,
+        buffer: [],
+        emitEvents: []
+      }
+    ),
+    rxjs.switchMap((state) => state.buffer.length > 0 ? rxjs.concat(
+      rxjs.of(state),
+      rxjs.timer(resolveChainDeadline).pipe(
+        operators.mergeMap(
+          () => rxjs.throwError(
+            () => new DeadlineExceededError(
+              `Did not resolve chain within a deadline of ${resolveChainDeadline}ms`,
+              state
+            )
+          )
+        )
+      )
+    ) : rxjs.of(state)),
+    // Emit all events that are ready to be applied.
+    operators.mergeMap((state) => rxjs.of(...state.emitEvents))
+  );
+}
+const listen = createInternalAction(({ state }) => {
+  const { sharedListener, fetchDocument } = state.get();
+  return function(documentId) {
+    return sharedListener.pipe(
+      rxjs.concatMap((e3) => e3.type === "welcome" ? fetchDocument(documentId).pipe(
+        rxjs.map((document2) => ({ type: "sync", document: document2 }))
+      ) : e3.type === "mutation" && e3.documentId === documentId ? rxjs.of(e3) : rxjs.EMPTY),
+      sortListenerEvents(),
+      rxjs.withLatestFrom(
+        state.observable.pipe(
+          rxjs.map((s2) => s2.documentStates[documentId]),
+          rxjs.filter(Boolean),
+          rxjs.distinctUntilChanged()
+        )
+      ),
+      rxjs.map(([next, documentState]) => {
+        if (next.type === "sync")
+          return {
+            type: "sync",
+            documentId,
+            document: next.document,
+            revision: next.document?._rev,
+            timestamp: next.document?._updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+          };
+        const [document2] = Object.values(
+          processMutations({
+            documents: { [documentId]: documentState.remote },
+            mutations: next.mutations,
+            transactionId: next.transactionId,
+            timestamp: next.timestamp
+          })
+        ), { previousRev, transactionId, timestamp } = next;
+        return {
+          type: "mutation",
+          documentId,
+          document: document2 ?? null,
+          revision: transactionId,
+          timestamp,
+          ...previousRev && { previousRev }
+        };
+      })
+    );
+  };
+});
+class e {
+  pattern;
+  patternRe;
+  constructor(e3) {
+    this.pattern = e3, this.patternRe = function(e4) {
+      const t2 = [];
+      for (const r2 of e4.split(".")) r2 === "*" ? t2.push("[^.]+") : r2 === "**" ? t2.push(".*") : t2.push(r2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+      return new RegExp(`^${t2.join(".")}$`);
+    }(e3);
+  }
+  matches(e3) {
+    return this.patternRe.test(e3);
+  }
+  toJSON() {
+    return this.pattern;
+  }
+}
+class t {
+  type = "stream";
+  generator;
+  ticker;
+  isDone;
+  data;
+  constructor(e3) {
+    this.generator = e3, this.ticker = null, this.isDone = !1, this.data = [];
+  }
+  isArray() {
+    return !0;
+  }
+  async get() {
+    const e3 = [];
+    for await (const t2 of this) e3.push(await t2.get());
+    return e3;
+  }
+  async first(e3 = () => !0) {
+    for await (const t2 of this) if (e3(t2)) return t2;
+  }
+  async reduce(e3, t2) {
+    let r2 = t2;
+    for await (const t3 of this) r2 = await e3(r2, t3);
+    return r2;
+  }
+  async *[Symbol.asyncIterator]() {
+    let e3 = 0;
+    for (; ; ) {
+      for (; e3 < this.data.length; e3++) yield this.data[e3];
+      if (this.isDone) return;
+      await this._nextTick();
+    }
+  }
+  _nextTick() {
+    if (this.ticker) return this.ticker;
+    let e3;
+    const t2 = () => {
+      this.ticker = new Promise((t3) => {
+        e3 = t3;
+      });
+    }, r2 = () => {
+      e3(), t2();
+    };
+    return t2(), (async () => {
+      for await (const e4 of this.generator()) this.data.push(e4), r2();
+      this.isDone = !0, r2();
+    })(), this.ticker;
+  }
+}
+const r = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|([-+]\d{2}:\d{2}))$/;
+function n(e3, t2) {
+  let r2 = e3.toString();
+  for (; r2.length < t2; ) r2 = `0${r2}`;
+  return r2;
+}
+class o {
+  data;
+  type;
+  constructor(e3, t2) {
+    this.data = e3, this.type = t2;
+  }
+  isArray() {
+    return this.type === "array";
+  }
+  get() {
+    return this.data;
+  }
+  first(e3 = () => !0) {
+    if (!this.isArray()) throw new Error("`first` can only be called on array `StaticValue`s");
+    const t2 = this.get();
+    for (const r2 of t2) {
+      const t3 = f(r2, "sync");
+      if (e3(t3)) return t3;
+    }
+  }
+  reduce(e3, t2) {
+    if (!this.isArray()) throw new Error("`reduce` can only be called on array `StaticValue`s");
+    const r2 = this.get();
+    let n2 = t2;
+    for (const t3 of r2)
+      n2 = e3(n2, f(t3, "sync"));
+    return n2;
+  }
+  [Symbol.asyncIterator]() {
+    if (Array.isArray(this.data)) return function* (e3) {
+      for (const t2 of e3) yield f(t2, "async");
+    }(this.data);
+    throw new Error(`Cannot iterate over: ${this.type}`);
+  }
+}
+const i = new o(null, "null"), s = new o(!0, "boolean"), a = new o(!1, "boolean");
+class c {
+  date;
+  constructor(e3) {
+    this.date = e3;
+  }
+  static parseToValue(e3) {
+    const t2 = function(e4) {
+      return r.test(e4) ? new Date(e4) : null;
+    }(e3);
+    return t2 ? new o(new c(t2), "datetime") : i;
+  }
+  equals(e3) {
+    return this.date.getTime() == e3.date.getTime();
+  }
+  add(e3) {
+    const t2 = new Date(this.date.getTime());
+    return t2.setTime(t2.getTime() + 1e3 * e3), new c(t2);
+  }
+  difference(e3) {
+    return (this.date.getTime() - e3.date.getTime()) / 1e3;
+  }
+  compareTo(e3) {
+    return this.date.getTime() - e3.date.getTime();
+  }
+  toString() {
+    return function(e3) {
+      const t2 = n(e3.getUTCFullYear(), 4), r2 = n(e3.getUTCMonth() + 1, 2), o2 = n(e3.getUTCDate(), 2), i2 = n(e3.getUTCHours(), 2), s2 = n(e3.getUTCMinutes(), 2), a2 = n(e3.getUTCSeconds(), 2);
+      let c2 = "";
+      const u2 = e3.getMilliseconds();
+      return u2 != 0 && (c2 = `.${n(u2, 3)}`), `${t2}-${r2}-${o2}T${i2}:${s2}:${a2}${c2}Z`;
+    }(this.date);
+  }
+  toJSON() {
+    return this.toString();
+  }
+}
+function u(e3) {
+  return Number.isFinite(e3) ? new o(e3, "number") : i;
+}
+function p(e3) {
+  return new o(e3, "string");
+}
+function l(e3) {
+  return new o(e3, "datetime");
+}
+function f(e3, r2) {
+  return (n2 = e3) && typeof n2.next == "function" && r2 !== "sync" ? new t(async function* () {
+    for await (const t2 of e3) yield f(t2, "async");
+  }) : e3 == null ? i : new o(e3, y(e3));
+  var n2;
+}
+function y(t2) {
+  return t2 === null || typeof t2 > "u" ? "null" : Array.isArray(t2) ? "array" : t2 instanceof e ? "path" : t2 instanceof c ? "datetime" : typeof t2;
+}
+const d = (e3) => typeof e3 == "object" && !!e3 && "then" in e3 && typeof e3.then == "function";
+function h(e3) {
+  const t2 = e3(), r2 = t2.next();
+  if (r2.done) return r2.value;
+  function n2(e4) {
+    const r3 = t2.next(e4);
+    if (r3.done) return r3.value;
+    const o3 = r3.value;
+    return o3 && d(o3) ? o3.then(n2) : n2(o3);
+  }
+  const o2 = r2.value;
+  return o2 && d(o2) ? o2.then(n2) : n2(o2);
+}
+function m(e3, t2) {
+  return e3.type === "string" && t2.type === "string" || e3.type === "boolean" && t2.type === "boolean" || e3.type === "null" && t2.type === "null" || e3.type === "number" && t2.type === "number" ? e3.data === t2.data : e3.type === "datetime" && t2.type === "datetime" && e3.data.equals(t2.data);
+}
+const b = /([^!@#$%^&*(),\\/?";:{}|[\]+<>\s-])+/g, g = /([^!@#$%^&(),\\/?";:{}|[\]+<>\s-])+/g, w = /(\b\.+|\.+\b)/g;
+function k(e3) {
+  return e3.replace(w, "").match(b) || [];
+}
+function v(e3) {
+  return x(e3).map((e4) => (t2) => t2.some((t3) => e4.test(t3)));
+}
+function x(e3) {
+  return (e3.replace(w, "").match(g) || []).map((e4) => new RegExp(`^${e4.slice(0, 1024).replace(/\*/g, ".*")}$`, "i"));
+}
+const _ = { datetime: 1, number: 2, string: 3, boolean: 4 };
+function A(e3, t2) {
+  const r2 = y(e3);
+  if (r2 !== y(t2)) return null;
+  switch (r2) {
+    case "number":
+    case "boolean":
+      return e3 - t2;
+    case "string":
+      return e3 < t2 ? -1 : e3 > t2 ? 1 : 0;
+    case "datetime":
+      return e3.compareTo(t2);
+    default:
+      return null;
+  }
+}
+function E(e3, t2) {
+  const r2 = y(e3), n2 = y(t2), o2 = _[r2] || 100, i2 = _[n2] || 100;
+  if (o2 !== i2) return o2 - i2;
+  let s2 = A(e3, t2);
+  return s2 === null && (s2 = 0), s2;
+}
+const j = { "==": function(e3, t2) {
+  return m(e3, t2) ? s : a;
+}, "!=": function(e3, t2) {
+  return m(e3, t2) ? a : s;
+}, ">": function(e3, t2) {
+  if (e3.type === "stream" || t2.type === "stream") return i;
+  const r2 = A(e3.data, t2.data);
+  return r2 === null ? i : r2 > 0 ? s : a;
+}, ">=": function(e3, t2) {
+  if (e3.type === "stream" || t2.type === "stream") return i;
+  const r2 = A(e3.data, t2.data);
+  return r2 === null ? i : r2 >= 0 ? s : a;
+}, "<": function(e3, t2) {
+  if (e3.type === "stream" || t2.type === "stream") return i;
+  const r2 = A(e3.data, t2.data);
+  return r2 === null ? i : r2 < 0 ? s : a;
+}, "<=": function(e3, t2) {
+  if (e3.type === "stream" || t2.type === "stream") return i;
+  const r2 = A(e3.data, t2.data);
+  return r2 === null ? i : r2 <= 0 ? s : a;
+}, in: function(e3, t2) {
+  return h(function* () {
+    return t2.type === "path" ? e3.type !== "string" ? i : t2.data.matches(e3.data) ? s : a : t2.isArray() ? (yield t2.first((t3) => m(e3, t3))) ? s : a : i;
+  });
+}, match: function(e3, t2) {
+  return h(function* () {
+    const r2 = yield e3.get(), n2 = yield t2.get();
+    let o2, i2 = [];
+    return Array.isArray(r2) ? i2 = r2.filter((e4) => typeof e4 == "string") : typeof r2 == "string" && (i2 = [r2]), Array.isArray(n2) ? o2 = n2.filter((e4) => typeof e4 == "string") : typeof n2 == "string" && (o2 = [n2]), o2?.length && function(e4, t3) {
+      return e4.length !== 0 && t3.length !== 0 && t3.every((t4) => t4(e4));
+    }(i2.flatMap(k), o2.flatMap(v)) ? s : a;
+  });
+}, "+": function(e3, r2, n2) {
+  return e3.type === "datetime" && r2.type === "number" ? l(e3.data.add(r2.data)) : e3.type === "number" && r2.type === "number" ? u(e3.data + r2.data) : e3.type === "string" && r2.type === "string" ? p(e3.data + r2.data) : e3.type === "object" && r2.type === "object" ? f({ ...e3.data, ...r2.data }, n2) : e3.type === "array" && r2.type === "array" ? f(e3.data.concat(r2.data), n2) : e3.isArray() && r2.isArray() ? n2 === "sync" ? h(function* () {
+    const t2 = [...yield e3.get(), ...yield r2.get()];
+    return new o(t2, "array");
+  }) : new t(async function* () {
+    for await (const t2 of e3) yield t2;
+    for await (const e4 of r2) yield e4;
+  }) : i;
+}, "-": function(e3, t2) {
+  return e3.type === "datetime" && t2.type === "number" ? l(e3.data.add(-t2.data)) : e3.type === "datetime" && t2.type === "datetime" ? u(e3.data.difference(t2.data)) : e3.type === "number" && t2.type === "number" ? u(e3.data - t2.data) : i;
+}, "*": S((e3, t2) => e3 * t2), "/": S((e3, t2) => e3 / t2), "%": S((e3, t2) => e3 % t2), "**": S((e3, t2) => Math.pow(e3, t2)) };
+function S(e3) {
+  return function(t2, r2) {
+    return t2.type === "number" && r2.type === "number" ? u(e3(t2.data, r2.data)) : i;
+  };
+}
+let O = class e2 {
+  params;
+  source;
+  value;
+  parent;
+  context;
+  isHidden = !1;
+  constructor(e3, t2, r2, n2, o2) {
+    this.params = e3, this.source = t2, this.value = r2, this.context = n2, this.parent = o2;
+  }
+  createNested(t2) {
+    return this.isHidden ? new e2(this.params, this.source, t2, this.context, this.parent) : new e2(this.params, this.source, t2, this.context, this);
+  }
+  createHidden(e3) {
+    const t2 = this.createNested(e3);
+    return t2.isHidden = !0, t2;
+  }
+};
+function I(e3, t2, r2) {
+  return (0, $[e3.type])(e3, t2, r2);
+}
+const $ = { This: (e3, t2) => t2.value, Selector() {
+  throw new Error("Selectors can not be evaluated");
+}, Everything: (e3, t2) => t2.source, Parameter: ({ name: e3 }, t2, r2) => f(t2.params[e3], r2), Context({ key: e3 }, t2) {
+  if (e3 === "before" || e3 === "after") return t2.context[e3] || i;
+  throw new Error(`unknown context key: ${e3}`);
+}, Parent({ n: e3 }, t2) {
+  let r2 = t2;
+  for (let t3 = 0; t3 < e3; t3++) {
+    if (!r2.parent) return i;
+    r2 = r2.parent;
+  }
+  return r2.value;
+}, OpCall: ({ op: e3, left: t2, right: r2 }, n2, o2) => h(function* () {
+  const i2 = j[e3];
+  if (!i2) throw new Error(`Unknown operator: ${e3}`);
+  const s2 = yield I(t2, n2, o2), a2 = yield I(r2, n2, o2);
+  return yield i2(s2, a2, o2);
+}), Select: ({ alternatives: e3, fallback: t2 }, r2, n2) => h(function* () {
+  for (const t3 of e3) {
+    const e4 = yield I(t3.condition, r2, n2);
+    if (e4.type === "boolean" && e4.data === !0) return yield I(t3.value, r2, n2);
+  }
+  return t2 ? yield I(t2, r2, n2) : i;
+}), InRange: ({ base: e3, left: t2, right: r2, isInclusive: n2 }, o2, c2) => h(function* () {
+  const u2 = yield I(e3, o2, c2), p2 = yield I(t2, o2, c2), l2 = yield I(r2, o2, c2), f2 = A(yield u2.get(), yield p2.get());
+  if (f2 === null) return i;
+  const y2 = A(yield u2.get(), yield l2.get());
+  return y2 === null ? i : n2 ? f2 >= 0 && y2 <= 0 ? s : a : f2 >= 0 && y2 < 0 ? s : a;
+}), Filter: ({ base: e3, expr: r2 }, n2, s2) => h(function* () {
+  const a2 = yield I(e3, n2, s2);
+  if (!a2.isArray()) return i;
+  if (s2 === "sync") {
+    const e4 = yield a2.get(), t2 = [];
+    for (const o2 of e4) {
+      const e5 = f(o2, s2), i2 = n2.createNested(e5), a3 = yield I(r2, i2, s2);
+      a3.type === "boolean" && a3.data === !0 && t2.push(o2);
+    }
+    return new o(t2, "array");
+  }
+  return new t(async function* () {
+    for await (const e4 of a2) {
+      const t2 = n2.createNested(e4), o2 = await I(r2, t2, s2);
+      o2.type === "boolean" && o2.data === !0 && (yield e4);
+    }
+  });
+}), Projection: ({ base: e3, expr: t2 }, r2, n2) => h(function* () {
+  const o2 = yield I(e3, r2, n2);
+  if (o2.type !== "object") return i;
+  const s2 = r2.createNested(o2);
+  return yield I(t2, s2, n2);
+}), FuncCall: ({ func: e3, args: t2 }, r2, n2) => e3(t2, r2, n2), PipeFuncCall: ({ func: e3, base: t2, args: r2 }, n2, o2) => h(function* () {
+  const i2 = yield I(t2, n2, o2);
+  return yield e3(i2, r2, n2, o2);
+}), AccessAttribute: ({ base: e3, name: t2 }, r2, n2) => h(function* () {
+  let o2 = r2.value;
+  return e3 && (o2 = yield I(e3, r2, n2)), o2.type === "object" && o2.data.hasOwnProperty(t2) ? f(o2.data[t2], n2) : i;
+}), AccessElement: ({ base: e3, index: t2 }, r2, n2) => h(function* () {
+  const o2 = yield I(e3, r2, n2);
+  if (!o2.isArray()) return i;
+  const s2 = yield o2.get();
+  return f(s2[t2 < 0 ? t2 + s2.length : t2], n2);
+}), Slice: ({ base: e3, left: t2, right: r2, isInclusive: n2 }, o2, s2) => h(function* () {
+  const a2 = yield I(e3, o2, s2);
+  if (!a2.isArray()) return i;
+  const c2 = yield a2.get();
+  let u2 = t2, p2 = r2;
+  return u2 < 0 && (u2 = c2.length + u2), p2 < 0 && (p2 = c2.length + p2), n2 && p2++, u2 < 0 && (u2 = 0), p2 < 0 && (p2 = 0), f(c2.slice(u2, p2), s2);
+}), Deref: ({ base: e3 }, t2, r2) => h(function* () {
+  const n2 = yield I(e3, t2, r2);
+  if (!t2.source.isArray() || n2.type !== "object") return i;
+  const o2 = n2.data._ref;
+  return typeof o2 != "string" ? i : t2.context.dereference ? f(yield t2.context.dereference({ _ref: o2 }), r2) : (yield t2.source.first((e4) => e4.type === "object" && o2 == e4.data._id)) || i;
+}), Value: ({ value: e3 }, t2, r2) => f(e3, r2), Group: ({ base: e3 }, t2, r2) => I(e3, t2, r2), Object: ({ attributes: e3 }, t2, r2) => h(function* () {
+  const n2 = {};
+  for (const o2 of e3) {
+    const e4 = o2.type;
+    switch (o2.type) {
+      case "ObjectAttributeValue": {
+        const e5 = yield I(o2.value, t2, r2);
+        n2[o2.name] = yield e5.get();
+        break;
+      }
+      case "ObjectConditionalSplat": {
+        const e5 = yield I(o2.condition, t2, r2);
+        if (e5.type !== "boolean" || e5.data === !1) continue;
+        const i2 = yield I(o2.value, t2, r2);
+        i2.type === "object" && Object.assign(n2, i2.data);
+        break;
+      }
+      case "ObjectSplat": {
+        const e5 = yield I(o2.value, t2, r2);
+        e5.type === "object" && Object.assign(n2, e5.data);
+        break;
+      }
+      default:
+        throw new Error(`Unknown node type: ${e4}`);
+    }
+  }
+  return f(n2, r2);
+}), Array: ({ elements: e3 }, r2, n2) => h(function* () {
+  if (n2 === "sync") {
+    const t2 = [];
+    for (const o2 of e3) {
+      const e4 = yield I(o2.value, r2, n2);
+      if (o2.isSplat) {
+        if (e4.isArray()) {
+          const r3 = yield e4.get();
+          t2.push(...r3);
+        }
+      } else t2.push(yield e4.get());
+    }
+    return new o(t2, "array");
+  }
+  return new t(async function* () {
+    for (const t2 of e3) {
+      const e4 = await I(t2.value, r2, n2);
+      if (t2.isSplat) {
+        if (e4.isArray()) for await (const t3 of e4) yield t3;
+      } else yield e4;
+    }
+  });
+}), Tuple() {
+  throw new Error("tuples can not be evaluated");
+}, Or: ({ left: e3, right: t2 }, r2, n2) => h(function* () {
+  const o2 = yield I(e3, r2, n2), c2 = yield I(t2, r2, n2);
+  return o2.type === "boolean" && o2.data === !0 || c2.type === "boolean" && c2.data === !0 ? s : o2.type !== "boolean" || c2.type !== "boolean" ? i : a;
+}), And: ({ left: e3, right: t2 }, r2, n2) => h(function* () {
+  const o2 = yield I(e3, r2, n2), c2 = yield I(t2, r2, n2);
+  return o2.type === "boolean" && o2.data === !1 || c2.type === "boolean" && c2.data === !1 ? a : o2.type !== "boolean" || c2.type !== "boolean" ? i : s;
+}), Not: ({ base: e3 }, t2, r2) => h(function* () {
+  const n2 = yield I(e3, t2, r2);
+  return n2.type !== "boolean" ? i : n2.data ? a : s;
+}), Neg: ({ base: e3 }, t2, r2) => h(function* () {
+  const n2 = yield I(e3, t2, r2);
+  return n2.type !== "number" ? i : u(-n2.data);
+}), Pos: ({ base: e3 }, t2, r2) => h(function* () {
+  const n2 = yield I(e3, t2, r2);
+  return n2.type !== "number" ? i : u(n2.data);
+}), Asc: () => i, Desc: () => i, ArrayCoerce: ({ base: e3 }, t2, r2) => h(function* () {
+  const n2 = yield I(e3, t2, r2);
+  return n2.isArray() ? n2 : i;
+}), Map: ({ base: e3, expr: r2 }, n2, s2) => h(function* () {
+  const a2 = yield I(e3, n2, s2);
+  if (!a2.isArray()) return i;
+  if (s2 === "sync") {
+    const e4 = yield a2.get(), t2 = [];
+    for (const o2 of e4) {
+      const e5 = f(o2, "sync"), i2 = n2.createHidden(e5), a3 = yield I(r2, i2, s2);
+      t2.push(yield a3.get());
+    }
+    return new o(t2, "array");
+  }
+  return new t(async function* () {
+    for await (const e4 of a2) {
+      const t2 = n2.createHidden(e4);
+      yield await I(r2, t2, s2);
+    }
+  });
+}), FlatMap: ({ base: e3, expr: r2 }, n2, s2) => h(function* () {
+  const a2 = yield I(e3, n2, s2);
+  if (!a2.isArray()) return i;
+  if (s2 === "sync") {
+    const e4 = yield a2.get(), t2 = [];
+    for (const o2 of e4) {
+      const e5 = f(o2, "sync"), i2 = n2.createHidden(e5), a3 = yield I(r2, i2, s2);
+      if (a3.isArray()) {
+        const e6 = yield a3.get();
+        t2.push(...e6);
+      } else {
+        const e6 = yield a3.get();
+        t2.push(e6);
+      }
+    }
+    return new o(t2, "array");
+  }
+  return new t(async function* () {
+    for await (const e4 of a2) {
+      const t2 = n2.createHidden(e4), o2 = await I(r2, t2, s2);
+      if (o2.isArray()) for await (const e5 of o2) yield e5;
+      else yield o2;
+    }
+  });
+}) };
+function C(e3, t2 = {}) {
+  const r2 = f(t2.root, "sync"), n2 = f(t2.dataset, "sync"), o2 = { ...t2.params }, i2 = new O(o2, n2, r2, function(e4 = {}, t3) {
+    return { timestamp: e4.timestamp || /* @__PURE__ */ new Date(), identity: e4.identity === void 0 ? "me" : e4.identity, sanity: e4.sanity, after: e4.after ? f(e4.after, t3) : null, before: e4.before ? f(e4.before, t3) : null, dereference: e4.dereference };
+  }(t2, "sync"), null), s2 = I(e3, i2, "sync");
+  if (d(s2)) throw new Error("Unexpected promise when evaluating. This expression may not support evaluateSync.");
+  return s2;
+}
+function M(e3) {
+  switch (e3.type) {
+    case "Group":
+      return M(e3.base);
+    case "Value":
+    case "Parameter":
+      return !0;
+    case "Pos":
+    case "Neg":
+      return M(e3.base);
+    case "OpCall":
+      switch (e3.op) {
+        case "+":
+        case "-":
+        case "*":
+        case "/":
+        case "%":
+        case "**":
+          return M(e3.left) && M(e3.right);
+        default:
+          return !1;
+      }
+    default:
+      return !1;
+  }
+}
+const T = new O({}, i, i, { timestamp: /* @__PURE__ */ new Date(0), identity: "me", before: null, after: null }, null);
+function P(e3) {
+  return M(e3) ? function(e4) {
+    const t2 = I(e4, T, "sync");
+    if (d(t2)) throw new Error("BUG: constant evaluate should never return a promise");
+    return t2;
+  }(e3) : null;
+}
+function N(e3, t2) {
+  return h(function* () {
+    if (e3.type === "object") return V(e3.data);
+    if (e3.isArray()) {
+      const r2 = yield U(e3, t2);
+      if (r2.length > 0) return r2.join(`
+
+`);
+    }
+    return null;
+  });
+}
+function U(e3, t2) {
+  return h(function* () {
+    const r2 = [], n2 = yield e3.get();
+    for (const e4 of n2) {
+      const n3 = f(e4, t2);
+      if (n3.type === "object") {
+        const e5 = V(n3.data);
+        e5 !== null && r2.push(e5);
+      } else if (n3.isArray()) {
+        const e5 = yield U(n3, t2);
+        r2.push(...e5);
+      }
+    }
+    return r2;
+  });
+}
+function V(e3) {
+  if (typeof e3._type != "string") return null;
+  const t2 = e3.children;
+  if (!Array.isArray(t2)) return null;
+  let r2 = "";
+  for (const e4 of t2) e4 && typeof e4 == "object" && typeof e4._type == "string" && e4._type === "span" && typeof e4.text == "string" && (r2 += e4.text);
+  return r2;
+}
+const D = 1.2;
+function F(e3, t2, r2) {
+  return h(function* () {
+    if (e3.type === "OpCall" && e3.op === "match")
+      return function(e4, t3) {
+        return h(function* () {
+          const r3 = yield e4.get(), n2 = yield t3.get();
+          let o2, i2 = [];
+          if (Array.isArray(r3) ? i2 = r3.filter((e5) => typeof e5 == "string") : typeof r3 == "string" && (i2 = [r3]), Array.isArray(n2) ? o2 = n2.filter((e5) => typeof e5 == "string") : typeof n2 == "string" && (o2 = [n2]), !o2?.length) return 0;
+          const s2 = i2.flatMap(k), a2 = o2.flatMap(x);
+          if (s2.length === 0 || a2.length === 0) return 0;
+          let c2 = 0;
+          for (const e5 of a2) {
+            const t4 = s2.reduce((t5, r4) => t5 + (e5.test(r4) ? 1 : 0), 0);
+            c2 += 2.2 * t4 / (t4 + D);
+          }
+          return c2;
+        });
+      }(yield I(e3.left, t2, r2), yield I(e3.right, t2, r2));
+    if (e3.type === "FuncCall" && e3.name === "boost") {
+      const n2 = yield F(e3.args[0], t2, r2), o2 = yield I(e3.args[1], t2, r2);
+      return o2.type === "number" && n2 > 0 ? n2 + o2.data : 0;
+    }
+    switch (e3.type) {
+      case "Or":
+        return (yield F(e3.left, t2, r2)) + (yield F(e3.right, t2, r2));
+      case "And": {
+        const n2 = yield F(e3.left, t2, r2), o2 = yield F(e3.right, t2, r2);
+        return n2 === 0 || o2 === 0 ? 0 : n2 + o2;
+      }
+      default: {
+        const n2 = yield I(e3, t2, r2);
+        return n2.type === "boolean" && n2.data === !0 ? 1 : 0;
+      }
+    }
+  });
+}
+function R(e3, t2) {
+  switch (y(e3)) {
+    case "array":
+      for (const r2 of e3) if (R(r2, t2)) return !0;
+      break;
+    case "object":
+      if (e3._ref) return t2.has(e3._ref);
+      for (const r2 of Object.values(e3)) if (R(r2, t2)) return !0;
+  }
+  return !1;
+}
+const q = { anywhere: function() {
+  throw new Error("not implemented");
+} };
+q.anywhere.arity = 1, q.coalesce = function(e3, t2, r2) {
+  return h(function* () {
+    for (const n2 of e3) {
+      const e4 = yield I(n2, t2, r2);
+      if (e4.type !== "null") return e4;
+    }
+    return i;
+  });
+}, q.count = function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    return n2.isArray() ? u(yield n2.reduce((e4) => e4 + 1, 0)) : i;
+  });
+}, q.count.arity = 1, q.dateTime = function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    return n2.type === "datetime" ? n2 : n2.type !== "string" ? i : c.parseToValue(n2.data);
+  });
+}, q.dateTime.arity = 1, q.defined = function(e3, t2, r2) {
+  return h(function* () {
+    return (yield I(e3[0], t2, r2)).type === "null" ? a : s;
+  });
+}, q.defined.arity = 1, q.identity = function(e3, t2) {
+  return p(t2.context.identity);
+}, q.identity.arity = 0, q.length = function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    return n2.type === "string" ? u(function(e4) {
+      let t3 = 0;
+      for (let r3 = 0; r3 < e4.length; r3++) {
+        const n3 = e4.charCodeAt(r3);
+        n3 >= 55296 && n3 <= 56319 || t3++;
+      }
+      return t3;
+    }(n2.data)) : n2.isArray() ? u(yield n2.reduce((e4) => e4 + 1, 0)) : i;
+  });
+}, q.length.arity = 1, q.path = function(t2, r2, n2) {
+  return h(function* () {
+    const s2 = yield I(t2[0], r2, n2);
+    return s2.type !== "string" ? i : (a2 = new e(s2.data), new o(a2, "path"));
+    var a2;
+  });
+}, q.path.arity = 1, q.string = function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    switch (n2.type) {
+      case "number":
+      case "string":
+      case "boolean":
+      case "datetime":
+        return p(`${n2.data}`);
+      default:
+        return i;
+    }
+  });
+}, q.string.arity = 1, q.references = function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = /* @__PURE__ */ new Set();
+    for (const o2 of e3) {
+      const e4 = yield I(o2, t2, r2);
+      if (e4.type === "string") n2.add(e4.data);
+      else if (e4.isArray()) {
+        const t3 = yield e4.get();
+        for (const e5 of t3) typeof e5 == "string" && n2.add(e5);
+      }
+    }
+    return n2.size === 0 ? a : R(yield t2.value.get(), n2) ? s : a;
+  });
+}, q.references.arity = (e3) => e3 >= 1, q.round = function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    if (n2.type !== "number") return i;
+    const o2 = n2.data;
+    let s2 = 0;
+    if (e3.length === 2) {
+      const n3 = yield I(e3[1], t2, r2);
+      if (n3.type !== "number" || n3.data < 0 || !Number.isInteger(n3.data)) return i;
+      s2 = n3.data;
+    }
+    return u(s2 === 0 ? o2 < 0 ? -Math.round(-o2) : Math.round(o2) : Number(o2.toFixed(s2)));
+  });
+}, q.round.arity = (e3) => e3 >= 1 && e3 <= 2, q.now = function(e3, t2) {
+  return p(t2.context.timestamp.toISOString());
+}, q.now.arity = 0, q.boost = function() {
+  throw new Error("unexpected boost call");
+}, q.boost.arity = 2;
+const G = { lower: function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    return n2.type !== "string" ? i : p(n2.data.toLowerCase());
+  });
+} };
+G.lower.arity = 1, G.upper = function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    return n2.type !== "string" ? i : p(n2.data.toUpperCase());
+  });
+}, G.upper.arity = 1, G.split = function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    if (n2.type !== "string") return i;
+    const o2 = yield I(e3[1], t2, r2);
+    return o2.type !== "string" ? i : n2.data.length === 0 ? f([], r2) : o2.data.length === 0 ? f(Array.from(n2.data), r2) : f(n2.data.split(o2.data), r2);
+  });
+}, G.split.arity = 2, q.lower = G.lower, q.upper = G.upper, G.startsWith = function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    if (n2.type !== "string") return i;
+    const o2 = yield I(e3[1], t2, r2);
+    return o2.type !== "string" ? i : n2.data.startsWith(o2.data) ? s : a;
+  });
+}, G.startsWith.arity = 2;
+const H = { join: function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    if (!n2.isArray()) return i;
+    const o2 = yield I(e3[1], t2, r2);
+    if (o2.type !== "string") return i;
+    let s2 = "", a2 = !1;
+    const c2 = yield n2.get();
+    for (const e4 of c2) {
+      const t3 = f(e4, r2);
+      switch (a2 && (s2 += o2.data), t3.type) {
+        case "number":
+        case "string":
+        case "boolean":
+        case "datetime":
+          s2 += `${t3.data}`;
+          break;
+        default:
+          return i;
+      }
+      a2 = !0;
+    }
+    return f(s2, r2);
+  });
+} };
+H.join.arity = 2, H.compact = function(e3, r2, n2) {
+  return h(function* () {
+    const o2 = yield I(e3[0], r2, n2);
+    return o2.isArray() ? new t(async function* () {
+      for await (const e4 of o2) e4.type !== "null" && (yield e4);
+    }) : i;
+  });
+}, H.compact.arity = 1, H.unique = function(e3, r2, n2) {
+  return h(function* () {
+    const s2 = yield I(e3[0], r2, n2);
+    if (!s2.isArray()) return i;
+    if (n2 === "sync") {
+      const e4 = yield s2.get(), t2 = /* @__PURE__ */ new Set(), r3 = [];
+      for (const n3 of e4) {
+        const e5 = f(n3, "sync");
+        switch (e5.type) {
+          case "number":
+          case "string":
+          case "boolean":
+          case "datetime":
+            t2.has(n3) || (t2.add(n3), r3.push(e5));
+            break;
+          default:
+            r3.push(e5);
+        }
+      }
+      return new o(r3, "array");
+    }
+    return new t(async function* () {
+      const e4 = /* @__PURE__ */ new Set();
+      for await (const t2 of s2) switch (t2.type) {
+        case "number":
+        case "string":
+        case "boolean":
+        case "datetime":
+          e4.has(t2.data) || (e4.add(t2.data), yield t2);
+          break;
+        default:
+          yield t2;
+      }
+    });
+  });
+}, H.unique.arity = 1, H.intersects = function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    if (!n2.isArray()) return i;
+    const o2 = yield I(e3[1], t2, r2);
+    return o2.isArray() ? (yield n2.first((e4) => !!o2.first((t3) => m(e4, t3)))) ? s : a : i;
+  });
+}, H.intersects.arity = 2;
+const B = { text: function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2), o2 = yield N(n2, r2);
+    return o2 === null ? i : p(o2);
+  });
+} };
+B.text.arity = 1;
+const W = { projectId: function(e3, t2) {
+  return t2.context.sanity ? p(t2.context.sanity.projectId) : i;
+}, dataset: function(e3, t2) {
+  return t2.context.sanity ? p(t2.context.sanity.dataset) : i;
+}, versionsOf: function(e3, t2, r2) {
+  return h(function* () {
+    if (!t2.source.isArray()) return i;
+    const n2 = yield I(e3[0], t2, r2);
+    if (n2.type !== "string") return i;
+    const o2 = n2.data;
+    return f(yield t2.source.reduce((e4, t3) => {
+      if (y(t3) === "object") {
+        const r3 = t3.get();
+        r3 && "_id" in r3 && r3._id.split(".").length === 2 && r3._id.endsWith(`.${o2}`) && "_version" in r3 && typeof r3._version == "object" && e4.push(r3._id);
+      }
+      return e4;
+    }, []), r2);
+  });
+} };
+W.versionsOf.arity = 1, W.partOfRelease = function(e3, t2, r2) {
+  return h(function* () {
+    if (!t2.source.isArray()) return i;
+    const n2 = yield I(e3[0], t2, r2);
+    if (n2.type !== "string") return i;
+    const o2 = n2.data;
+    return f(yield t2.source.reduce((e4, t3) => {
+      if (y(t3) === "object") {
+        const r3 = t3.get();
+        r3 && "_id" in r3 && r3._id.split(".").length === 2 && r3._id.startsWith(`${o2}.`) && "_version" in r3 && typeof r3._version == "object" && e4.push(r3._id);
+      }
+      return e4;
+    }, []), r2);
+  });
+}, W.partOfRelease.arity = 1;
+const Z = { order: function(e3, t2, r2, n2) {
+  return h(function* () {
+    if (!e3.isArray()) return i;
+    const o2 = [], s2 = [];
+    let a2 = 0;
+    for (let e4 of t2) {
+      let t3 = "asc";
+      e4.type === "Desc" ? (t3 = "desc", e4 = e4.base) : e4.type === "Asc" && (e4 = e4.base), o2.push(e4), s2.push(t3), a2++;
+    }
+    const c2 = [];
+    let u2 = 0;
+    const p2 = yield e3.get();
+    for (const e4 of p2) {
+      const t3 = f(e4, n2), i2 = r2.createNested(t3), s3 = [yield t3.get(), u2];
+      for (let e5 = 0; e5 < a2; e5++) {
+        const t4 = yield I(o2[e5], i2, n2);
+        s3.push(yield t4.get());
+      }
+      c2.push(s3), u2++;
+    }
+    return c2.sort((e4, t3) => {
+      for (let r3 = 0; r3 < a2; r3++) {
+        let n3 = E(e4[r3 + 2], t3[r3 + 2]);
+        if (s2[r3] === "desc" && (n3 = -n3), n3 !== 0) return n3;
+      }
+      return e4[1] - t3[1];
+    }), f(c2.map((e4) => e4[0]), n2);
+  });
+} };
+Z.order.arity = (e3) => e3 >= 1, Z.score = function(e3, t2, r2, n2) {
+  return h(function* () {
+    if (!e3.isArray()) return i;
+    const o2 = [], s2 = [], a2 = yield e3.get();
+    for (const e4 of a2) {
+      const i2 = f(e4, n2);
+      if (i2.type !== "object") {
+        o2.push(yield i2.get());
+        continue;
+      }
+      const a3 = r2.createNested(i2);
+      let c2 = typeof i2.data._score == "number" ? i2.data._score : 0;
+      for (const e5 of t2) c2 += yield F(e5, a3, n2);
+      const u2 = Object.assign({}, i2.data, { _score: c2 });
+      s2.push(u2);
+    }
+    return s2.sort((e4, t3) => t3._score - e4._score), f(s2, n2);
+  });
+}, Z.score.arity = (e3) => e3 >= 1;
+const z = { operation: function(e3, t2) {
+  const r2 = t2.context.before !== null, n2 = t2.context.after !== null;
+  return r2 && n2 ? p("update") : n2 ? p("create") : r2 ? p("delete") : i;
+}, changedAny: () => {
+  throw new Error("not implemented");
+} };
+z.changedAny.arity = 1, z.changedAny.mode = "delta", z.changedOnly = () => {
+  throw new Error("not implemented");
+}, z.changedOnly.arity = 1, z.changedOnly.mode = "delta";
+const J = { changedAny: () => {
+  throw new Error("not implemented");
+} };
+J.changedAny.arity = 3, J.changedOnly = () => {
+  throw new Error("not implemented");
+}, J.changedOnly.arity = 3;
+const Q = { min: function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    if (!n2.isArray() || (yield n2.first((e4) => e4.type !== "null" && e4.type !== "number"))) return i;
+    const o2 = yield n2.get();
+    let s2;
+    for (const e4 of o2) typeof e4 == "number" && (s2 === void 0 || e4 < s2) && (s2 = e4);
+    return f(s2, r2);
+  });
+} };
+Q.min.arity = 1, Q.max = function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    if (!n2.isArray() || (yield n2.first((e4) => e4.type !== "null" && e4.type !== "number"))) return i;
+    const o2 = yield n2.get();
+    let s2;
+    for (const e4 of o2) typeof e4 == "number" && (s2 === void 0 || e4 > s2) && (s2 = e4);
+    return f(s2, r2);
+  });
+}, Q.max.arity = 1, Q.sum = function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    return !n2.isArray() || (yield n2.first((e4) => e4.type !== "null" && e4.type !== "number")) ? i : f(yield n2.reduce((e4, t3) => t3.type !== "number" ? e4 : e4 + t3.data, 0), r2);
+  });
+}, Q.sum.arity = 1, Q.avg = function(e3, t2, r2) {
+  return h(function* () {
+    const n2 = yield I(e3[0], t2, r2);
+    if (!n2.isArray() || (yield n2.first((e4) => e4.type !== "null" && e4.type !== "number"))) return i;
+    const o2 = yield n2.reduce((e4, t3) => t3.type !== "number" ? e4 : e4 + 1, 0), s2 = yield n2.reduce((e4, t3) => t3.type !== "number" ? e4 : e4 + t3.data, 0);
+    return o2 === 0 ? i : f(s2 / o2, r2);
+  });
+}, Q.avg.arity = 1;
+const L = { now: function(e3, t2) {
+  return l(new c(t2.context.timestamp));
+} };
+L.now.arity = 0;
+const Y = { global: q, string: G, array: H, pt: B, delta: z, diff: J, sanity: W, math: Q, dateTime: L };
+class K {
+  string;
+  marks;
+  index;
+  parseOptions;
+  allowBoost = !1;
+  constructor(e3, t2, r2) {
+    this.string = e3, this.marks = t2, this.index = 0, this.parseOptions = r2;
+  }
+  hasMark(e3 = 0) {
+    return this.index + e3 < this.marks.length;
+  }
+  getMark(e3 = 0) {
+    return this.marks[this.index + e3];
+  }
+  shift() {
+    this.index += 1;
+  }
+  process(e3) {
+    const t2 = this.marks[this.index];
+    this.shift();
+    const r2 = e3[t2.name];
+    if (!r2) throw new Error(`Unknown handler: ${t2.name}`);
+    return r2.call(e3, this, t2);
+  }
+  processString() {
+    return this.shift(), this.processStringEnd();
+  }
+  processStringEnd() {
+    const e3 = this.marks[this.index - 1], t2 = this.marks[this.index];
+    return this.shift(), this.string.slice(e3.position, t2.position);
+  }
+  slice(e3) {
+    const t2 = this.marks[this.index].position;
+    return this.string.slice(t2, t2 + e3);
+  }
+}
+const X = /^([\t\n\v\f\r \u0085\u00A0]|(\/\/[^\n]*\n))+/, ee = /^\d+/, te = /^[a-zA-Z_][a-zA-Z_0-9]*/;
+function re(e3, t2, r2) {
+  let n2, o2 = t2;
+  switch (e3[t2]) {
+    case "+": {
+      let r3 = re(e3, se(e3, t2 + 1), 10);
+      if (r3.type === "error") return r3;
+      n2 = [{ name: "pos", position: o2 }].concat(r3.marks), t2 = r3.position;
+      break;
+    }
+    case "-": {
+      let r3 = re(e3, se(e3, t2 + 1), 8);
+      if (r3.type === "error") return r3;
+      n2 = [{ name: "neg", position: o2 }].concat(r3.marks), t2 = r3.position;
+      break;
+    }
+    case "(": {
+      let r3 = re(e3, se(e3, t2 + 1), 0);
+      if (r3.type === "error") return r3;
+      switch (e3[t2 = se(e3, r3.position)]) {
+        case ",":
+          for (n2 = [{ name: "tuple", position: o2 }].concat(r3.marks), t2 = se(e3, t2 + 1); ; ) {
+            if (r3 = re(e3, t2, 0), r3.type === "error") return r3;
+            if (e3[t2 = se(e3, r3.position)] !== ",") break;
+            t2 = se(e3, t2 + 1);
+          }
+          if (e3[t2] !== ")") return { type: "error", position: t2 };
+          t2++, n2.push({ name: "tuple_end", position: t2 });
+          break;
+        case ")":
+          t2++, n2 = [{ name: "group", position: o2 }].concat(r3.marks);
+          break;
+        default:
+          return { type: "error", position: t2 };
+      }
+      break;
+    }
+    case "!": {
+      let r3 = re(e3, se(e3, t2 + 1), 10);
+      if (r3.type === "error") return r3;
+      n2 = [{ name: "not", position: o2 }].concat(r3.marks), t2 = r3.position;
+      break;
+    }
+    case "{": {
+      let r3 = ie(e3, t2);
+      if (r3.type === "error") return r3;
+      n2 = r3.marks, t2 = r3.position;
+      break;
+    }
+    case "[":
+      if (n2 = [{ name: "array", position: t2 }], e3[t2 = se(e3, t2 + 1)] !== "]") for (; ; ) {
+        e3.slice(t2, t2 + 3) === "..." && (n2.push({ name: "array_splat", position: t2 }), t2 = se(e3, t2 + 3));
+        let r3 = re(e3, t2, 0);
+        if (r3.type === "error") return r3;
+        if (n2 = n2.concat(r3.marks), e3[t2 = se(e3, t2 = r3.position)] !== "," || e3[t2 = se(e3, t2 + 1)] === "]") break;
+      }
+      if (e3[t2] !== "]") return { type: "error", position: t2 };
+      t2++, n2.push({ name: "array_end", position: t2 });
+      break;
+    case "'":
+    case '"': {
+      let r3 = function(e4, t3) {
+        let r4 = e4[t3];
+        t3 += 1;
+        const n3 = [{ name: "str", position: t3 }];
+        e: for (; ; t3++) {
+          if (t3 > e4.length) return { type: "error", position: t3 };
+          switch (e4[t3]) {
+            case r4:
+              n3.push({ name: "str_end", position: t3 }), t3++;
+              break e;
+            case "\\":
+              n3.push({ name: "str_pause", position: t3 }), e4[t3 + 1] === "u" ? e4[t3 + 2] === "{" ? (n3.push({ name: "unicode_hex", position: t3 + 3 }), t3 = e4.indexOf("}", t3 + 3), n3.push({ name: "unicode_hex_end", position: t3 })) : (n3.push({ name: "unicode_hex", position: t3 + 2 }), n3.push({ name: "unicode_hex_end", position: t3 + 6 }), t3 += 5) : (n3.push({ name: "single_escape", position: t3 + 1 }), t3 += 1), n3.push({ name: "str_start", position: t3 + 1 });
+          }
+        }
+        return { type: "success", marks: n3, position: t3 };
+      }(e3, t2);
+      if (r3.type === "error") return r3;
+      n2 = r3.marks, t2 = r3.position;
+      break;
+    }
+    case "^":
+      for (t2++, n2 = []; e3[t2] === "." && e3[t2 + 1] === "^"; ) n2.push({ name: "dblparent", position: o2 }), t2 += 2;
+      n2.push({ name: "parent", position: o2 });
+      break;
+    case "@":
+      n2 = [{ name: "this", position: o2 }], t2++;
+      break;
+    case "*":
+      n2 = [{ name: "everything", position: o2 }], t2++;
+      break;
+    case "$": {
+      let r3 = ae(e3, t2 + 1, te);
+      r3 && (n2 = [{ name: "param", position: o2 }, { name: "ident", position: o2 + 1 }, { name: "ident_end", position: t2 += 1 + r3 }]);
+      break;
+    }
+    default: {
+      let r3 = ae(e3, t2, ee);
+      if (r3) {
+        let i4 = "integer";
+        if (e3[t2 += r3] === ".") {
+          let r4 = ae(e3, t2 + 1, ee);
+          r4 && (i4 = "float", t2 += 1 + r4);
+        }
+        if (e3[t2] === "e" || e3[t2] === "E") {
+          i4 = "sci", (e3[++t2] === "+" || e3[t2] === "-") && t2++;
+          let r4 = ae(e3, t2, ee);
+          if (!r4) return { type: "error", position: t2 };
+          t2 += r4;
+        }
+        n2 = [{ name: i4, position: o2 }, { name: i4 + "_end", position: t2 }];
+        break;
+      }
+      let i3 = ae(e3, t2, te);
+      if (i3) {
+        switch (e3[t2 += i3]) {
+          case ":":
+          case "(": {
+            let r4 = oe(e3, o2, t2);
+            if (r4.type === "error") return r4;
+            n2 = r4.marks, t2 = r4.position;
+            break;
+          }
+          default:
+            n2 = [{ name: "this_attr", position: o2 }, { name: "ident", position: o2 }, { name: "ident_end", position: t2 }];
+        }
+        break;
+      }
+    }
+  }
+  if (!n2) return { type: "error", position: t2 };
+  let i2, s2 = 12;
+  e: for (; ; ) {
+    let a2 = se(e3, t2);
+    if (a2 === e3.length) {
+      t2 = a2;
+      break;
+    }
+    if (i2 = ne(e3, a2), i2.type !== "success") switch (e3[a2]) {
+      case "=":
+        switch (e3[a2 + 1]) {
+          case ">": {
+            if (r2 > 1 || s2 <= 1) break e;
+            let i3 = re(e3, se(e3, a2 + 2), 1);
+            if (i3.type === "error") return i3;
+            n2 = n2.concat(i3.marks), n2.unshift({ name: "pair", position: o2 }), t2 = i3.position, s2 = 1;
+            break;
+          }
+          case "=": {
+            if (r2 > 4 || s2 <= 4) break e;
+            let i3 = re(e3, se(e3, a2 + 2), 5);
+            if (i3.type === "error") return i3;
+            n2.unshift({ name: "comp", position: o2 }), n2.push({ name: "op", position: a2 }, { name: "op_end", position: a2 + 2 }), n2 = n2.concat(i3.marks), t2 = i3.position, s2 = 4;
+            break;
+          }
+          default:
+            break e;
+        }
+        break;
+      case "+": {
+        if (r2 > 6 || s2 < 6) break e;
+        let i3 = re(e3, se(e3, a2 + 1), 7);
+        if (i3.type === "error") return i3;
+        n2 = n2.concat(i3.marks), n2.unshift({ name: "add", position: o2 }), t2 = i3.position, s2 = 6;
+        break;
+      }
+      case "-": {
+        if (r2 > 6 || s2 < 6) break e;
+        let i3 = re(e3, se(e3, a2 + 1), 7);
+        if (i3.type === "error") return i3;
+        n2 = n2.concat(i3.marks), n2.unshift({ name: "sub", position: o2 }), t2 = i3.position, s2 = 6;
+        break;
+      }
+      case "*": {
+        if (e3[a2 + 1] === "*") {
+          if (r2 > 8 || s2 <= 8) break e;
+          let i4 = re(e3, se(e3, a2 + 2), 8);
+          if (i4.type === "error") return i4;
+          n2 = n2.concat(i4.marks), n2.unshift({ name: "pow", position: o2 }), t2 = i4.position, s2 = 8;
+          break;
+        }
+        if (r2 > 7 || s2 < 7) break e;
+        let i3 = re(e3, se(e3, a2 + 1), 8);
+        if (i3.type === "error") return i3;
+        n2 = n2.concat(i3.marks), n2.unshift({ name: "mul", position: o2 }), t2 = i3.position, s2 = 7;
+        break;
+      }
+      case "/": {
+        if (r2 > 7 || s2 < 7) break e;
+        let i3 = re(e3, se(e3, a2 + 1), 8);
+        if (i3.type === "error") return i3;
+        n2 = n2.concat(i3.marks), n2.unshift({ name: "div", position: o2 }), t2 = i3.position, s2 = 7;
+        break;
+      }
+      case "%": {
+        if (r2 > 7 || s2 < 7) break e;
+        let i3 = re(e3, se(e3, a2 + 1), 8);
+        if (i3.type === "error") return i3;
+        n2 = n2.concat(i3.marks), n2.unshift({ name: "mod", position: o2 }), t2 = i3.position, s2 = 7;
+        break;
+      }
+      case "<":
+      case ">": {
+        if (r2 > 4 || s2 <= 4) break e;
+        let i3 = a2 + 1;
+        e3[i3] === "=" && i3++;
+        let c2 = re(e3, se(e3, i3), 5);
+        if (c2.type === "error") return c2;
+        n2.unshift({ name: "comp", position: o2 }), n2.push({ name: "op", position: a2 }, { name: "op_end", position: i3 }), n2 = n2.concat(c2.marks), t2 = c2.position, s2 = 4;
+        break;
+      }
+      case "|":
+        if (e3[a2 + 1] === "|") {
+          if (r2 > 2 || s2 < 2) break e;
+          let i3 = re(e3, se(e3, a2 + 2), 3);
+          if (i3.type === "error") return i3;
+          n2 = n2.concat(i3.marks), n2.unshift({ name: "or", position: o2 }), t2 = i3.position, s2 = 2;
+        } else {
+          if (r2 > 11 || s2 < 11) break e;
+          let i3 = se(e3, a2 + 1), c2 = ae(e3, i3, te);
+          if (!c2) return { type: "error", position: i3 };
+          if (e3[t2 = i3 + c2] === "(" || e3[t2] === ":") {
+            let r3 = oe(e3, i3, t2);
+            if (r3.type === "error") return r3;
+            n2 = n2.concat(r3.marks), n2.unshift({ name: "pipecall", position: o2 }), t2 = r3.position, s2 = 11;
+          }
+        }
+        break;
+      case "&": {
+        if (e3[a2 + 1] != "&" || r2 > 3 || s2 < 3) break e;
+        let i3 = re(e3, se(e3, a2 + 2), 4);
+        if (i3.type === "error") return i3;
+        n2 = n2.concat(i3.marks), n2.unshift({ name: "and", position: o2 }), t2 = i3.position, s2 = 3;
+        break;
+      }
+      case "!": {
+        if (e3[a2 + 1] !== "=" || r2 > 4 || s2 <= 4) break e;
+        let i3 = re(e3, se(e3, a2 + 2), 5);
+        if (i3.type === "error") return i3;
+        n2.unshift({ name: "comp", position: o2 }), n2.push({ name: "op", position: a2 }, { name: "op_end", position: a2 + 2 }), n2 = n2.concat(i3.marks), t2 = i3.position, s2 = 4;
+        break;
+      }
+      case "d":
+        if (e3.slice(a2, a2 + 4) !== "desc" || r2 > 4 || s2 < 4) break e;
+        n2.unshift({ name: "desc", position: o2 }), t2 = a2 + 4, s2 = 4;
+        break;
+      case "a":
+        if (e3.slice(a2, a2 + 3) !== "asc" || r2 > 4 || s2 < 4) break e;
+        n2.unshift({ name: "asc", position: o2 }), t2 = a2 + 3, s2 = 4;
+        break;
+      default:
+        switch (ce(e3, a2, te)) {
+          case "in": {
+            if (r2 > 4 || s2 <= 4) break e;
+            let i3 = !1;
+            e3[t2 = se(e3, a2 + 2)] === "(" && (i3 = !0, t2 = se(e3, t2 + 1));
+            let c2 = t2, u2 = re(e3, t2, 5);
+            if (u2.type === "error") return u2;
+            if (e3[t2 = se(e3, u2.position)] === "." && e3[t2 + 1] === ".") {
+              let r3 = "inc_range";
+              e3[t2 + 2] === "." ? (r3 = "exc_range", t2 = se(e3, t2 + 3)) : t2 = se(e3, t2 + 2);
+              let i4 = re(e3, t2, 5);
+              if (i4.type === "error") return i4;
+              n2.unshift({ name: "in_range", position: o2 }), n2 = n2.concat({ name: r3, position: c2 }, u2.marks, i4.marks), t2 = i4.position;
+            } else n2.unshift({ name: "comp", position: o2 }), n2.push({ name: "op", position: a2 }, { name: "op_end", position: a2 + 2 }), n2 = n2.concat(u2.marks);
+            if (i3) {
+              if (e3[t2 = se(e3, t2)] !== ")") return { type: "error", position: t2 };
+              t2++;
+            }
+            s2 = 4;
+            break;
+          }
+          case "match": {
+            if (r2 > 4 || s2 <= 4) break e;
+            let i3 = re(e3, se(e3, a2 + 5), 5);
+            if (i3.type === "error") return i3;
+            n2.unshift({ name: "comp", position: o2 }), n2.push({ name: "op", position: a2 }, { name: "op_end", position: a2 + 5 }), n2 = n2.concat(i3.marks), t2 = i3.position, s2 = 4;
+            break;
+          }
+          default:
+            break e;
+        }
+    }
+    else {
+      for (n2.unshift({ name: "traverse", position: o2 }); i2.type === "success"; ) n2 = n2.concat(i2.marks), i2 = ne(e3, se(e3, t2 = i2.position));
+      n2.push({ name: "traversal_end", position: t2 });
+    }
+  }
+  return { type: "success", marks: n2, position: t2, failPosition: i2?.type === "error" && i2.position };
+}
+function ne(e3, t2) {
+  let r2 = t2;
+  switch (e3[t2]) {
+    case ".": {
+      let n3 = t2 = se(e3, t2 + 1), o3 = ae(e3, t2, te);
+      return o3 ? { type: "success", marks: [{ name: "attr_access", position: r2 }, { name: "ident", position: n3 }, { name: "ident_end", position: t2 += o3 }], position: t2 } : { type: "error", position: t2 };
+    }
+    case "-":
+      if (e3[t2 + 1] !== ">") return { type: "error", position: t2 };
+      let n2 = [{ name: "deref", position: r2 }], o2 = se(e3, t2 += 2), i2 = ae(e3, o2, te);
+      return i2 && (t2 = o2 + i2, n2.push({ name: "deref_attr", position: o2 }, { name: "ident", position: o2 }, { name: "ident_end", position: t2 })), { type: "success", marks: n2, position: t2 };
+    case "[": {
+      if (e3[t2 = se(e3, t2 + 1)] === "]") return { type: "success", marks: [{ name: "array_postfix", position: r2 }], position: t2 + 1 };
+      let n3 = t2, o3 = re(e3, t2, 0);
+      if (o3.type === "error") return o3;
+      if (e3[t2 = se(e3, o3.position)] === "." && e3[t2 + 1] === ".") {
+        let i3 = "inc_range";
+        e3[t2 + 2] === "." ? (i3 = "exc_range", t2 += 3) : t2 += 2;
+        let s2 = re(e3, t2 = se(e3, t2), 0);
+        return s2.type === "error" ? s2 : e3[t2 = se(e3, s2.position)] !== "]" ? { type: "error", position: t2 } : { type: "success", marks: [{ name: "slice", position: r2 }, { name: i3, position: n3 }].concat(o3.marks, s2.marks), position: t2 + 1 };
+      }
+      return e3[t2] !== "]" ? { type: "error", position: t2 } : { type: "success", marks: [{ name: "square_bracket", position: r2 }].concat(o3.marks), position: t2 + 1 };
+    }
+    case "|":
+      if (e3[t2 = se(e3, t2 + 1)] === "{") {
+        let n3 = ie(e3, t2);
+        return n3.type === "error" || n3.marks.unshift({ name: "projection", position: r2 }), n3;
+      }
+      break;
+    case "{": {
+      let n3 = ie(e3, t2);
+      return n3.type === "error" || n3.marks.unshift({ name: "projection", position: r2 }), n3;
+    }
+  }
+  return { type: "error", position: t2 };
+}
+function oe(e3, t2, r2) {
+  let n2 = [];
+  if (n2.push({ name: "func_call", position: t2 }), e3[r2] === ":" && e3[r2 + 1] === ":") {
+    n2.push({ name: "namespace", position: t2 }), n2.push({ name: "ident", position: t2 }, { name: "ident_end", position: r2 });
+    let o3 = ae(e3, r2 = se(e3, r2 + 2), te);
+    if (!o3) return { type: "error", position: r2 };
+    if (n2.push({ name: "ident", position: r2 }, { name: "ident_end", position: r2 + o3 }), e3[r2 = se(e3, r2 + o3)] !== "(") return { type: "error", position: r2 };
+    r2 = se(e3, ++r2);
+  } else n2.push({ name: "ident", position: t2 }, { name: "ident_end", position: r2 }), r2 = se(e3, r2 + 1);
+  let o2 = r2;
+  if (e3[r2] !== ")") for (; ; ) {
+    let t3 = re(e3, r2, 0);
+    if (t3.type === "error") return t3;
+    if (n2 = n2.concat(t3.marks), o2 = t3.position, e3[r2 = se(e3, t3.position)] !== "," || e3[r2 = se(e3, r2 + 1)] === ")") break;
+  }
+  return e3[r2] !== ")" ? { type: "error", position: r2 } : (n2.push({ name: "func_args_end", position: o2 }), { type: "success", marks: n2, position: r2 + 1 });
+}
+function ie(e3, t2) {
+  let r2 = [{ name: "object", position: t2 }];
+  for (t2 = se(e3, t2 + 1); e3[t2] !== "}"; ) {
+    let n2 = t2;
+    if (e3.slice(t2, t2 + 3) === "...") if (e3[t2 = se(e3, t2 + 3)] !== "}" && e3[t2] !== ",") {
+      let o2 = re(e3, t2, 0);
+      if (o2.type === "error") return o2;
+      r2.push({ name: "object_splat", position: n2 }), r2 = r2.concat(o2.marks), t2 = o2.position;
+    } else r2.push({ name: "object_splat_this", position: n2 });
+    else {
+      let o2 = re(e3, t2, 0);
+      if (o2.type === "error") return o2;
+      let i2 = se(e3, o2.position);
+      if (o2.marks[0].name === "str" && e3[i2] === ":") {
+        let s2 = re(e3, se(e3, i2 + 1), 0);
+        if (s2.type === "error") return s2;
+        r2.push({ name: "object_pair", position: n2 }), r2 = r2.concat(o2.marks, s2.marks), t2 = s2.position;
+      } else r2 = r2.concat({ name: "object_expr", position: t2 }, o2.marks), t2 = o2.position;
+    }
+    if (e3[t2 = se(e3, t2)] !== ",") break;
+    t2 = se(e3, t2 + 1);
+  }
+  return e3[t2] !== "}" ? { type: "error", position: t2 } : (t2++, r2.push({ name: "object_end", position: t2 }), { type: "success", marks: r2, position: t2 });
+}
+function se(e3, t2) {
+  return t2 + ae(e3, t2, X);
+}
+function ae(e3, t2, r2) {
+  let n2 = r2.exec(e3.slice(t2));
+  return n2 ? n2[0].length : 0;
+}
+function ce(e3, t2, r2) {
+  let n2 = r2.exec(e3.slice(t2));
+  return n2 ? n2[0] : null;
+}
+function ue(e3, t2) {
+  return (r2) => t2(e3(r2));
+}
+function pe(e3) {
+  return (t2) => ({ type: "Map", base: t2, expr: e3({ type: "This" }) });
+}
+function le(e3, t2) {
+  if (!t2) return { type: "a-a", build: e3 };
+  switch (t2.type) {
+    case "a-a":
+      return { type: "a-a", build: ue(e3, t2.build) };
+    case "a-b":
+      return { type: "a-b", build: ue(e3, t2.build) };
+    case "b-b":
+      return { type: "a-a", build: ue(e3, pe(t2.build)) };
+    case "b-a":
+      return { type: "a-a", build: ue(e3, (r2 = t2.build, (e4) => ({ type: "FlatMap", base: e4, expr: r2({ type: "This" }) }))) };
+    default:
+      throw new Error(`unknown type: ${t2.type}`);
+  }
+  var r2;
+}
+function fe(e3, t2) {
+  if (!t2) return { type: "b-b", build: e3 };
+  switch (t2.type) {
+    case "a-a":
+    case "b-a":
+      return { type: "b-a", build: ue(e3, t2.build) };
+    case "a-b":
+    case "b-b":
+      return { type: "b-b", build: ue(e3, t2.build) };
+    default:
+      throw new Error(`unknown type: ${t2.type}`);
+  }
+}
+const ye = { "'": "'", '"': '"', "\\": "\\", "/": "/", b: "\b", f: "\f", n: `
+`, r: "\r", t: "	" };
+function de(e3) {
+  const t2 = parseInt(e3, 16);
+  return String.fromCharCode(t2);
+}
+class he extends Error {
+  name = "GroqQueryError";
+}
+const me = { group: (e3) => ({ type: "Group", base: e3.process(me) }), everything: () => ({ type: "Everything" }), this: () => ({ type: "This" }), parent: () => ({ type: "Parent", n: 1 }), dblparent: (e3) => ({ type: "Parent", n: e3.process(me).n + 1 }), traverse(e3) {
+  const t2 = e3.process(me), r2 = [];
+  for (; e3.getMark().name !== "traversal_end"; ) r2.push(e3.process(ge));
+  e3.shift();
+  let n2 = null;
+  for (let e4 = r2.length - 1; e4 >= 0; e4--) n2 = r2[e4](n2);
+  if ((t2.type === "Everything" || t2.type === "Array" || t2.type === "PipeFuncCall") && (n2 = le((e4) => e4, n2)), n2 === null) throw new Error("BUG: unexpected empty traversal");
+  return n2.build(t2);
+}, this_attr(e3) {
+  const t2 = e3.processString();
+  return t2 === "null" ? { type: "Value", value: null } : t2 === "true" ? { type: "Value", value: !0 } : t2 === "false" ? { type: "Value", value: !1 } : { type: "AccessAttribute", name: t2 };
+}, neg: (e3) => ({ type: "Neg", base: e3.process(me) }), pos: (e3) => ({ type: "Pos", base: e3.process(me) }), add: (e3) => ({ type: "OpCall", op: "+", left: e3.process(me), right: e3.process(me) }), sub: (e3) => ({ type: "OpCall", op: "-", left: e3.process(me), right: e3.process(me) }), mul: (e3) => ({ type: "OpCall", op: "*", left: e3.process(me), right: e3.process(me) }), div: (e3) => ({ type: "OpCall", op: "/", left: e3.process(me), right: e3.process(me) }), mod: (e3) => ({ type: "OpCall", op: "%", left: e3.process(me), right: e3.process(me) }), pow: (e3) => ({ type: "OpCall", op: "**", left: e3.process(me), right: e3.process(me) }), comp(e3) {
+  const t2 = e3.process(me);
+  return { type: "OpCall", op: e3.processString(), left: t2, right: e3.process(me) };
+}, in_range(e3) {
+  const t2 = e3.process(me), r2 = e3.getMark().name === "inc_range";
+  return e3.shift(), { type: "InRange", base: t2, left: e3.process(me), right: e3.process(me), isInclusive: r2 };
+}, str(e3) {
+  let t2 = "";
+  e: for (; e3.hasMark(); ) {
+    const r2 = e3.getMark();
+    switch (r2.name) {
+      case "str_end":
+        t2 += e3.processStringEnd();
+        break e;
+      case "str_pause":
+        t2 += e3.processStringEnd();
+        break;
+      case "str_start":
+        e3.shift();
+        break;
+      case "single_escape": {
+        const r3 = e3.slice(1);
+        e3.shift(), t2 += ye[r3];
+        break;
+      }
+      case "unicode_hex":
+        e3.shift(), t2 += de(e3.processStringEnd());
+        break;
+      default:
+        throw new Error(`unexpected mark: ${r2.name}`);
+    }
+  }
+  return { type: "Value", value: t2 };
+}, integer(e3) {
+  const t2 = e3.processStringEnd();
+  return { type: "Value", value: Number(t2) };
+}, float(e3) {
+  const t2 = e3.processStringEnd();
+  return { type: "Value", value: Number(t2) };
+}, sci(e3) {
+  const t2 = e3.processStringEnd();
+  return { type: "Value", value: Number(t2) };
+}, object(e3) {
+  const t2 = [];
+  for (; e3.getMark().name !== "object_end"; ) t2.push(e3.process(be));
+  return e3.shift(), { type: "Object", attributes: t2 };
+}, array(e3) {
+  const t2 = [];
+  for (; e3.getMark().name !== "array_end"; ) {
+    let r2 = !1;
+    e3.getMark().name === "array_splat" && (r2 = !0, e3.shift());
+    const n2 = e3.process(me);
+    t2.push({ type: "ArrayElement", value: n2, isSplat: r2 });
+  }
+  return e3.shift(), { type: "Array", elements: t2 };
+}, tuple(e3) {
+  const t2 = [];
+  for (; e3.getMark().name !== "tuple_end"; ) t2.push(e3.process(me));
+  return e3.shift(), { type: "Tuple", members: t2 };
+}, func_call(e3) {
+  let t2 = "global";
+  e3.getMark().name === "namespace" && (e3.shift(), t2 = e3.processString());
+  const r2 = e3.processString();
+  if (t2 === "global" && r2 === "select") {
+    const t3 = { type: "Select", alternatives: [] };
+    for (; e3.getMark().name !== "func_args_end"; ) if (e3.getMark().name === "pair") {
+      if (t3.fallback) throw new he("unexpected argument to select()");
+      e3.shift();
+      const r3 = e3.process(me), n3 = e3.process(me);
+      t3.alternatives.push({ type: "SelectAlternative", condition: r3, value: n3 });
+    } else {
+      if (t3.fallback) throw new he("unexpected argument to select()");
+      const r3 = e3.process(me);
+      t3.fallback = r3;
+    }
+    return e3.shift(), t3;
+  }
+  const n2 = [];
+  for (; e3.getMark().name !== "func_args_end"; ) xe(t2, r2, n2.length) ? (e3.process(we), n2.push({ type: "Selector" })) : n2.push(e3.process(me));
+  if (e3.shift(), t2 === "global" && (r2 === "before" || r2 === "after") && e3.parseOptions.mode === "delta") return { type: "Context", key: r2 };
+  if (t2 === "global" && r2 === "boost" && !e3.allowBoost) throw new he("unexpected boost");
+  const o2 = Y[t2];
+  if (!o2) throw new he(`Undefined namespace: ${t2}`);
+  const i2 = o2[r2];
+  if (!i2) throw new he(`Undefined function: ${r2}`);
+  if (i2.arity !== void 0 && ve(r2, i2.arity, n2.length), i2.mode !== void 0 && i2.mode !== e3.parseOptions.mode) throw new he(`Undefined function: ${r2}`);
+  return { type: "FuncCall", func: i2, namespace: t2, name: r2, args: n2 };
+}, pipecall(e3) {
+  const t2 = e3.process(me);
+  e3.shift();
+  let r2 = "global";
+  if (e3.getMark().name === "namespace" && (e3.shift(), r2 = e3.processString()), r2 !== "global") throw new he(`Undefined namespace: ${r2}`);
+  const n2 = e3.processString(), o2 = [], i2 = e3.allowBoost;
+  for (n2 === "score" && (e3.allowBoost = !0); ; ) {
+    const t3 = e3.getMark().name;
+    if (t3 === "func_args_end") break;
+    if (n2 === "order") {
+      if (t3 === "asc") {
+        e3.shift(), o2.push({ type: "Asc", base: e3.process(me) });
+        continue;
+      }
+      if (t3 === "desc") {
+        e3.shift(), o2.push({ type: "Desc", base: e3.process(me) });
+        continue;
+      }
+    }
+    o2.push(e3.process(me));
+  }
+  e3.shift(), e3.allowBoost = i2;
+  const s2 = Z[n2];
+  if (!s2) throw new he(`Undefined pipe function: ${n2}`);
+  return s2.arity && ve(n2, s2.arity, o2.length), { type: "PipeFuncCall", func: s2, base: t2, name: n2, args: o2 };
+}, pair() {
+  throw new he("unexpected =>");
+}, and: (e3) => ({ type: "And", left: e3.process(me), right: e3.process(me) }), or: (e3) => ({ type: "Or", left: e3.process(me), right: e3.process(me) }), not: (e3) => ({ type: "Not", base: e3.process(me) }), asc() {
+  throw new he("unexpected asc");
+}, desc() {
+  throw new he("unexpected desc");
+}, param(e3) {
+  const t2 = e3.processString();
+  return e3.parseOptions.params && e3.parseOptions.params.hasOwnProperty(t2) ? { type: "Value", value: e3.parseOptions.params[t2] } : { type: "Parameter", name: t2 };
+} }, be = { object_expr(e3) {
+  if (e3.getMark().name === "pair")
+    return e3.shift(), { type: "ObjectConditionalSplat", condition: e3.process(me), value: e3.process(me) };
+  const t2 = e3.process(me);
+  return { type: "ObjectAttributeValue", name: ke(t2), value: t2 };
+}, object_pair(e3) {
+  const t2 = e3.process(me);
+  if (t2.type !== "Value") throw new Error("name must be string");
+  const r2 = e3.process(me);
+  return { type: "ObjectAttributeValue", name: t2.value, value: r2 };
+}, object_splat: (e3) => ({ type: "ObjectSplat", value: e3.process(me) }), object_splat_this: () => ({ type: "ObjectSplat", value: { type: "This" } }) }, ge = { square_bracket(e3) {
+  const t2 = e3.process(me), r2 = P(t2);
+  return r2 && r2.type === "number" ? (e4) => function(e5, t3) {
+    if (!t3) return { type: "a-b", build: e5 };
+    switch (t3.type) {
+      case "a-a":
+      case "b-a":
+        return { type: "a-a", build: ue(e5, t3.build) };
+      case "a-b":
+      case "b-b":
+        return { type: "a-b", build: ue(e5, t3.build) };
+      default:
+        throw new Error(`unknown type: ${t3.type}`);
+    }
+  }((e5) => ({ type: "AccessElement", base: e5, index: r2.data }), e4) : r2 && r2.type === "string" ? (e4) => fe((e5) => ({ type: "AccessAttribute", base: e5, name: r2.data }), e4) : (e4) => le((e5) => ({ type: "Filter", base: e5, expr: t2 }), e4);
+}, slice(e3) {
+  const t2 = e3.getMark().name === "inc_range";
+  e3.shift();
+  const r2 = e3.process(me), n2 = e3.process(me), o2 = P(r2), i2 = P(n2);
+  if (!o2 || !i2 || o2.type !== "number" || i2.type !== "number") throw new he("slicing must use constant numbers");
+  return (e4) => le((e5) => ({ type: "Slice", base: e5, left: o2.data, right: i2.data, isInclusive: t2 }), e4);
+}, projection(e3) {
+  const t2 = e3.process(me);
+  return (e4) => function(e5, t3) {
+    if (!t3) return { type: "b-b", build: e5 };
+    switch (t3.type) {
+      case "a-a":
+        return { type: "a-a", build: ue(pe(e5), t3.build) };
+      case "a-b":
+        return { type: "a-b", build: ue(pe(e5), t3.build) };
+      case "b-a":
+        return { type: "b-a", build: ue(e5, t3.build) };
+      case "b-b":
+        return { type: "b-b", build: ue(e5, t3.build) };
+      default:
+        throw new Error(`unknown type: ${t3.type}`);
+    }
+  }((e5) => ({ type: "Projection", base: e5, expr: t2 }), e4);
+}, attr_access(e3) {
+  const t2 = e3.processString();
+  return (e4) => fe((e5) => ({ type: "AccessAttribute", base: e5, name: t2 }), e4);
+}, deref(e3) {
+  let t2 = null;
+  return e3.getMark().name === "deref_attr" && (e3.shift(), t2 = e3.processString()), (e4) => fe((e5) => /* @__PURE__ */ ((e6) => t2 ? { type: "AccessAttribute", base: e6, name: t2 } : e6)({ type: "Deref", base: e5 }), e4);
+}, array_postfix: () => (e3) => le((e4) => ({ type: "ArrayCoerce", base: e4 }), e3) }, we = { group: (e3) => (e3.process(we), null), everything() {
+  throw new Error("Invalid selector syntax");
+}, this() {
+  throw new Error("Invalid selector syntax");
+}, parent() {
+  throw new Error("Invalid selector syntax");
+}, dblparent() {
+  throw new Error("Invalid selector syntax");
+}, traverse(e3) {
+  for (e3.process(we); e3.getMark().name !== "traversal_end"; ) e3.process(ge);
+  return e3.shift(), null;
+}, this_attr: (e3) => (e3.processString(), null), neg() {
+  throw new Error("Invalid selector syntax");
+}, pos() {
+  throw new Error("Invalid selector syntax");
+}, add() {
+  throw new Error("Invalid selector syntax");
+}, sub() {
+  throw new Error("Invalid selector syntax");
+}, mul() {
+  throw new Error("Invalid selector syntax");
+}, div() {
+  throw new Error("Invalid selector syntax");
+}, mod() {
+  throw new Error("Invalid selector syntax");
+}, pow() {
+  throw new Error("Invalid selector syntax");
+}, comp() {
+  throw new Error("Invalid selector syntax");
+}, in_range() {
+  throw new Error("Invalid selector syntax");
+}, str() {
+  throw new Error("Invalid selector syntax");
+}, integer() {
+  throw new Error("Invalid selector syntax");
+}, float() {
+  throw new Error("Invalid selector syntax");
+}, sci() {
+  throw new Error("Invalid selector syntax");
+}, object() {
+  throw new Error("Invalid selector syntax");
+}, array() {
+  throw new Error("Invalid selector syntax");
+}, tuple() {
+  throw new Error("Invalid selector syntax");
+}, func_call(e3, t2) {
+  const r2 = me.func_call(e3, t2);
+  if (r2.name === "anywhere" && r2.args.length === 1) return null;
+  throw new Error("Invalid selector syntax");
+}, pipecall() {
+  throw new Error("Invalid selector syntax");
+}, pair() {
+  throw new Error("Invalid selector syntax");
+}, and() {
+  throw new Error("Invalid selector syntax");
+}, or() {
+  throw new Error("Invalid selector syntax");
+}, not() {
+  throw new Error("Invalid selector syntax");
+}, asc() {
+  throw new Error("Invalid selector syntax");
+}, desc() {
+  throw new Error("Invalid selector syntax");
+}, param() {
+  throw new Error("Invalid selector syntax");
+} };
+function ke(e3) {
+  if (e3.type === "AccessAttribute" && !e3.base) return e3.name;
+  if (e3.type === "PipeFuncCall" || e3.type === "Deref" || e3.type === "Map" || e3.type === "Projection" || e3.type === "Slice" || e3.type === "Filter" || e3.type === "AccessElement" || e3.type === "ArrayCoerce" || e3.type === "Group") return ke(e3.base);
+  throw new he(`Cannot determine property key for type: ${e3.type}`);
+}
+function ve(e3, t2, r2) {
+  if (typeof t2 == "number") {
+    if (r2 !== t2) throw new he(`Incorrect number of arguments to function ${e3}(). Expected ${t2}, got ${r2}.`);
+  } else if (t2 && !t2(r2)) throw new he(`Incorrect number of arguments to function ${e3}().`);
+}
+function xe(e3, t2, r2) {
+  return e3 == "diff" && r2 == 2 && ["changedAny", "changedOnly"].includes(t2);
+}
+class _e extends Error {
+  position;
+  name = "GroqSyntaxError";
+  constructor(e3) {
+    super(`Syntax error in GROQ query at position ${e3}`), this.position = e3;
+  }
+}
+function Ae(e3, t2 = {}) {
+  const r2 = function(e4) {
+    let t3 = 0;
+    t3 = se(e4, t3);
+    let r3 = re(e4, t3, 0);
+    return r3.type === "error" ? r3 : (t3 = se(e4, r3.position), t3 !== e4.length ? (r3.failPosition && (t3 = r3.failPosition - 1), { type: "error", position: t3 }) : (delete r3.position, delete r3.failPosition, r3));
+  }(e3);
+  if (r2.type === "error") throw new _e(r2.position);
+  return new K(e3, r2.marks, t2).process(me);
+}
+const isRecord = (value) => typeof value == "object" && !!value && !Array.isArray(value), ignoredKeys = ["_id", "_type", "_createdAt", "_updatedAt", "_rev"];
+function diffPatch(before, after) {
+  return diffRecursive(before, after, []);
+}
+function diffRecursive(before, after, path) {
+  if (before === after) return [];
+  const patches = [], pathStr = stringifyPath(path);
+  if (before === null || after === null)
+    return before !== after && patches.push({ set: { [pathStr]: after } }), patches;
+  if (typeof before != typeof after || Array.isArray(before) !== Array.isArray(after))
+    return patches.push({ set: { [pathStr]: after } }), patches;
+  if (typeof before == "string" && typeof after == "string") {
+    const dmpPatches = diffMatchPatch$1.makePatches(before, after), patchStr = diffMatchPatch$1.stringifyPatches(dmpPatches);
+    return patches.push({ diffMatchPatch: { [pathStr]: patchStr } }), patches;
+  }
+  if (typeof before == "number" && typeof after == "number")
+    return patches.push({ set: { [pathStr]: after } }), patches;
+  if (typeof before != "object")
+    return before !== after && patches.push({ set: { [pathStr]: after } }), patches;
+  if (Array.isArray(before) && Array.isArray(after))
+    return patches.push(...diffArray(before, after, path)), patches;
+  if (!isRecord(after) || !isRecord(before)) return patches;
+  const beforeKeys = Object.keys(before).filter((k2) => !ignoredKeys.includes(k2)), afterKeys = Object.keys(after).filter((k2) => !ignoredKeys.includes(k2)), allKeys = /* @__PURE__ */ new Set([...beforeKeys, ...afterKeys]);
+  for (const key of allKeys) {
+    const subPath = [...path, key];
+    key in after ? key in before ? patches.push(...diffRecursive(before[key], after[key], subPath)) : patches.push({ set: { [stringifyPath(subPath)]: after[key] } }) : patches.push({ unset: [stringifyPath(subPath)] });
+  }
+  return patches;
+}
+function diffArray(beforeArr, afterArr, path) {
+  const pathStr = stringifyPath(path), isKeyedArray = (arr) => arr.every((item) => types.isKeyedObject(item));
+  if (isKeyedArray(beforeArr) && isKeyedArray(afterArr)) {
+    if (beforeArr.length === 0 && afterArr.length > 0)
+      return [
+        {
+          insert: {
+            before: stringifyPath([...path, 0]),
+            items: afterArr
+          }
+        }
+      ];
+    const unsetPatches = [], diffPatches = [], insertPatches = [], beforeMap = /* @__PURE__ */ new Map();
+    beforeArr.forEach((item, index) => {
+      beforeMap.set(item._key, { item, index });
+    });
+    const afterMap = /* @__PURE__ */ new Map();
+    afterArr.forEach((item, index) => {
+      afterMap.set(item._key, { item, index });
+    });
+    for (const [key] of beforeMap.entries())
+      afterMap.has(key) || unsetPatches.push({ unset: [stringifyPath([...path, { _key: key }])] });
+    for (const [key, { item: afterItem }] of afterMap.entries())
+      beforeMap.has(key) && diffPatches.push(
+        ...diffRecursive(beforeMap.get(key).item, afterItem, [...path, { _key: key }])
+      );
+    let newItemsGroup = [], insertPosition = null;
+    for (let i2 = 0; i2 < afterArr.length; i2++) {
+      const item = afterArr[i2];
+      if (beforeMap.has(item._key))
+        newItemsGroup.length > 0 && insertPosition && (insertPosition.op === "before" ? insertPatches.push({
+          insert: {
+            before: stringifyPath([...path, { _key: insertPosition.refKey }]),
+            items: newItemsGroup
+          }
+        }) : insertPatches.push({
+          insert: {
+            after: stringifyPath([...path, { _key: insertPosition.refKey }]),
+            items: newItemsGroup
+          }
+        }), newItemsGroup = [], insertPosition = null);
+      else {
+        if (newItemsGroup.length === 0)
+          if (i2 === 0) {
+            let j2 = i2;
+            for (; j2 < afterArr.length && !beforeMap.has(afterArr[j2]._key); )
+              j2++;
+            j2 < afterArr.length ? insertPosition = { op: "before", refKey: afterArr[j2]._key } : beforeArr.length > 0 && (insertPosition = { op: "after", refKey: beforeArr[beforeArr.length - 1]._key });
+          } else {
+            let j2 = i2 - 1;
+            for (; j2 >= 0 && !beforeMap.has(afterArr[j2]._key); )
+              j2--;
+            if (j2 >= 0)
+              insertPosition = { op: "after", refKey: afterArr[j2]._key };
+            else {
+              let k2 = i2;
+              for (; k2 < afterArr.length && !beforeMap.has(afterArr[k2]._key); )
+                k2++;
+              k2 < afterArr.length && (insertPosition = { op: "before", refKey: afterArr[k2]._key });
+            }
+          }
+        newItemsGroup.push(item);
+      }
+    }
+    return newItemsGroup.length > 0 && insertPosition && (insertPosition.op === "after" ? insertPatches.push({
+      insert: {
+        after: stringifyPath([...path, { _key: insertPosition.refKey }]),
+        items: newItemsGroup
+      }
+    }) : insertPatches.push({
+      insert: {
+        before: stringifyPath([...path, { _key: insertPosition.refKey }]),
+        items: newItemsGroup
+      }
+    })), afterArr.every((item) => !beforeMap.has(item._key)) ? [...insertPatches, ...unsetPatches, ...diffPatches] : [...unsetPatches, ...diffPatches, ...insertPatches];
+  } else {
+    const patches = [], minLength = Math.min(beforeArr.length, afterArr.length);
+    for (let i2 = 0; i2 < minLength; i2++)
+      patches.push(...diffRecursive(beforeArr[i2], afterArr[i2], [...path, i2]));
+    for (let i2 = afterArr.length; i2 < beforeArr.length; i2++)
+      patches.push({ unset: [stringifyPath([...path, i2])] });
+    if (afterArr.length > beforeArr.length) {
+      const newItems = afterArr.slice(beforeArr.length);
+      beforeArr.length > 0 ? patches.push({
+        insert: { after: stringifyPath([...path, beforeArr.length - 1]), items: newItems }
+      }) : patches.push({ set: { [pathStr]: afterArr } });
+    }
+    return patches;
+  }
+}
+class MultiKeyWeakMap {
+  // The root of our nested WeakMap structure.
+  #rootMap = /* @__PURE__ */ new WeakMap();
+  // Instead of random IDs, we use a counter for deterministic IDs.
+  static #globalIdCounter = 0;
+  // Each instance keeps a cache mapping a key to its assigned ID.
+  #idCache = /* @__PURE__ */ new WeakMap();
+  /**
+   * Assigns a numeric ID to the key.
+   */
+  #assignId(key) {
+    const cachedId = this.#idCache.get(key);
+    if (cachedId !== void 0) return cachedId;
+    const id = MultiKeyWeakMap.#globalIdCounter;
+    return this.#idCache.set(key, id), MultiKeyWeakMap.#globalIdCounter++, id;
+  }
+  /**
+   * Remove duplicate keys and arrange them in a consistent order
+   * by sorting according to their assigned IDs.
+   */
+  #arrangeKeys(keys) {
+    const keyed = Array.from(new Set(keys)).map((key) => [this.#assignId(key), key]);
+    return keyed.sort((a2, b2) => a2[0] - b2[0]), keyed.map(([, key]) => key);
+  }
+  /**
+   * Recursively search the nested WeakMap structure for the value.
+   */
+  #getDeep(keys, map) {
+    if (keys.length === 0) return;
+    const [firstKey, ...restKeys] = keys, node = map.get(firstKey);
+    if (node)
+      return restKeys.length === 0 ? node.value : this.#getDeep(restKeys, node.next);
+  }
+  /**
+   * Recursively create nodes along the key chain until the final key
+   * is reached, then assign the value.
+   */
+  #setDeep(keys, map, value) {
+    if (keys.length === 0) return;
+    const [firstKey, ...restKeys] = keys;
+    let node = map.get(firstKey);
+    node || (node = {
+      value: void 0,
+      next: /* @__PURE__ */ new WeakMap()
+    }, map.set(firstKey, node)), restKeys.length === 0 ? node.value = value : this.#setDeep(restKeys, node.next, value);
+  }
+  /**
+   * Retrieves the value associated with the array of keys.
+   * The keys are de-duplicated and sorted so that the order does not matter.
+   */
+  get(keys) {
+    const arrangedKeys = this.#arrangeKeys(keys);
+    return this.#getDeep(arrangedKeys, this.#rootMap);
+  }
+  /**
+   * Associates the value with the given array of keys.
+   */
+  set(keys, value) {
+    const arrangedKeys = this.#arrangeKeys(keys);
+    this.#setDeep(arrangedKeys, this.#rootMap, value);
+  }
+}
+function createGrantsLookup(datasetAcl) {
+  const filtersByGrant = {
+    create: /* @__PURE__ */ new Set(),
+    history: /* @__PURE__ */ new Set(),
+    read: /* @__PURE__ */ new Set(),
+    update: /* @__PURE__ */ new Set()
+  };
+  for (const entry of datasetAcl)
+    for (const grant of entry.permissions) {
+      const set2 = filtersByGrant[grant];
+      set2.add(entry.filter), filtersByGrant[grant] = set2;
+    }
+  return Object.fromEntries(
+    Object.entries(filtersByGrant).map(([grant, filters]) => {
+      const combinedFilter = Array.from(filters).map((i2) => `(${i2})`).join("||");
+      return combinedFilter ? [grant, Ae(`$document {"_": ${combinedFilter}}._`)] : [grant, Ae("false")];
+    })
+  );
+}
+const documentsCache = new MultiKeyWeakMap(), actionsCache = /* @__PURE__ */ new WeakMap(), nullReplacer = {}, documentsSelector = reselect.createSelector(
+  [
+    ({ documentStates }) => documentStates,
+    (_state, actions) => actions
+  ],
+  (documentStates, actions) => {
+    const documentIds = new Set(
+      (Array.isArray(actions) ? actions : [actions]).map((i2) => i2.documentId).filter((i2) => typeof i2 == "string").flatMap((documentId) => [getPublishedId(documentId), getDraftId(documentId)])
+    ), documents = {};
+    for (const documentId of documentIds) {
+      const local = documentStates[documentId]?.local;
+      if (local === void 0) return;
+      documents[documentId] = local;
+    }
+    const keys = Object.values(
+      // value in this record will be `undefined` because
+      // of the early return if undefined is found above
+      documents
+    ).map((doc) => doc === null ? nullReplacer : doc);
+    return documentsCache.get(keys) || (documentsCache.set(keys, documents), documents);
+  }
+), memoizedActionsSelector = reselect.createSelector(
+  [
+    documentsSelector,
+    (_state, actions) => actions
+  ],
+  (documents, actions) => {
+    if (!documents) return;
+    let nestedCache = actionsCache.get(documents);
+    nestedCache || (nestedCache = /* @__PURE__ */ new Map(), actionsCache.set(documents, nestedCache));
+    const normalizedActions = Array.isArray(actions) ? actions : [actions], actionsKey = JSON.stringify(normalizedActions);
+    return nestedCache.get(actionsKey) || (nestedCache.set(actionsKey, normalizedActions), normalizedActions);
+  }
+);
+function checkGrant$1(grantExpr, document2) {
+  return C(grantExpr, { params: { document: document2 } }).get();
+}
+const enNarrowConjunction = new Intl.ListFormat("en", { style: "narrow", type: "conjunction" }), calculatePermissions = reselect.createSelector(
+  [({ grants }) => grants, documentsSelector, memoizedActionsSelector],
+  (grants, documents, actions) => {
+    if (!documents || !grants || !actions) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString(), reasons = [];
+    try {
+      processActions({
+        actions,
+        transactionId: crypto.randomUUID(),
+        working: documents,
+        base: documents,
+        timestamp,
+        grants
+      });
+    } catch (error) {
+      if (error instanceof PermissionActionError)
+        reasons.push({
+          message: error.message,
+          documentId: error.documentId,
+          type: "access"
+        });
+      else if (error instanceof ActionError)
+        reasons.push({
+          message: error.message,
+          documentId: error.documentId,
+          type: "precondition"
+        });
+      else
+        throw error;
+    }
+    for (const action of actions)
+      if (action.type === "document.edit" && !action.patches?.length) {
+        const docId = action.documentId, doc = documents[getDraftId(docId)] ?? documents[getPublishedId(docId)];
+        doc ? checkGrant$1(grants.update, doc) || reasons.push({
+          type: "access",
+          message: `You are not allowed to edit the document with ID "${docId}".`,
+          documentId: docId
+        }) : reasons.push({
+          type: "precondition",
+          message: `The document with ID "${docId}" could not be found. Please check that it exists before editing.`,
+          documentId: docId
+        });
+      }
+    const allowed = reasons.length === 0;
+    if (allowed) return { allowed };
+    const sortedReasons = reasons.map((reason, index) => ({ ...reason, index })).sort((a2, b2) => a2.type !== b2.type ? a2.type === "access" ? -1 : 1 : a2.message.localeCompare(b2.message, "en-US")).map(({ index: _index, ...reason }) => reason);
+    return {
+      allowed,
+      reasons: sortedReasons,
+      message: enNarrowConjunction.format(sortedReasons.map((i2) => i2.message))
+    };
+  }
+);
+function checkGrant(grantExpr, document2) {
+  return C(grantExpr, { params: { document: document2 } }).get();
+}
+class ActionError extends Error {
+  documentId;
+  transactionId;
+  constructor(options) {
+    super(options.message), Object.assign(this, options);
+  }
+}
+class PermissionActionError extends ActionError {
+}
+function processActions({
+  actions,
+  transactionId,
+  working: initialWorking,
+  base: initialBase,
+  timestamp,
+  grants
+}) {
+  let working = { ...initialWorking }, base = { ...initialBase };
+  const outgoingActions = [], outgoingMutations = [];
+  for (const action of actions)
+    switch (action.type) {
+      case "document.create": {
+        const documentId = getId(action.documentId), draftId = getDraftId(documentId), publishedId = getPublishedId(documentId);
+        if (working[draftId])
+          throw new ActionError({
+            documentId,
+            transactionId,
+            message: "A draft version of this document already exists. Please use or discard the existing draft before creating a new one."
+          });
+        const newDocBase = { ...base[publishedId], _type: action.documentType, _id: draftId }, newDocWorking = { ...working[publishedId], _type: action.documentType, _id: draftId }, mutations = [{ create: newDocWorking }];
+        if (base = processMutations({
+          documents: base,
+          transactionId,
+          mutations: [{ create: newDocBase }],
+          timestamp
+        }), working = processMutations({
+          documents: working,
+          transactionId,
+          mutations,
+          timestamp
+        }), !checkGrant(grants.create, working[draftId]))
+          throw new PermissionActionError({
+            documentId,
+            transactionId,
+            message: `You do not have permission to create a draft for document "${documentId}".`
+          });
+        outgoingMutations.push(...mutations), outgoingActions.push({
+          actionType: "sanity.action.document.version.create",
+          publishedId,
+          attributes: newDocWorking
+        });
+        continue;
+      }
+      case "document.delete": {
+        const documentId = action.documentId, draftId = getDraftId(documentId), publishedId = getPublishedId(documentId);
+        if (!working[publishedId])
+          throw new ActionError({
+            documentId,
+            transactionId,
+            message: working[draftId] ? "Cannot delete a document without a published version." : "The document you are trying to delete does not exist."
+          });
+        const cantDeleteDraft = working[draftId] && !checkGrant(grants.update, working[draftId]), cantDeletePublished = working[publishedId] && !checkGrant(grants.update, working[publishedId]);
+        if (cantDeleteDraft || cantDeletePublished)
+          throw new PermissionActionError({
+            documentId,
+            transactionId,
+            message: "You do not have permission to delete this document."
+          });
+        const mutations = [{ delete: { id: publishedId } }, { delete: { id: draftId } }], includeDrafts = working[draftId] ? [draftId] : void 0;
+        base = processMutations({ documents: base, transactionId, mutations, timestamp }), working = processMutations({ documents: working, transactionId, mutations, timestamp }), outgoingMutations.push(...mutations), outgoingActions.push({
+          actionType: "sanity.action.document.delete",
+          publishedId,
+          ...includeDrafts ? { includeDrafts } : {}
+        });
+        continue;
+      }
+      case "document.discard": {
+        const documentId = getId(action.documentId), draftId = getDraftId(documentId), mutations = [{ delete: { id: draftId } }];
+        if (!working[draftId])
+          throw new ActionError({
+            documentId,
+            transactionId,
+            message: `There is no draft available to discard for document "${documentId}".`
+          });
+        if (!checkGrant(grants.update, working[draftId]))
+          throw new PermissionActionError({
+            documentId,
+            transactionId,
+            message: `You do not have permission to discard changes for document "${documentId}".`
+          });
+        base = processMutations({ documents: base, transactionId, mutations, timestamp }), working = processMutations({ documents: working, transactionId, mutations, timestamp }), outgoingMutations.push(...mutations), outgoingActions.push({
+          actionType: "sanity.action.document.version.discard",
+          versionId: draftId
+        });
+        continue;
+      }
+      case "document.edit": {
+        const documentId = getId(action.documentId), draftId = getDraftId(documentId), publishedId = getPublishedId(documentId), userPatches = action.patches?.map((patch) => ({ patch: { id: draftId, ...patch } }));
+        if (!userPatches?.length) continue;
+        if (!working[draftId] && !working[publishedId] || !base[draftId] && !base[publishedId])
+          throw new ActionError({
+            documentId,
+            transactionId,
+            message: "Cannot edit document because it does not exist in draft or published form."
+          });
+        const baseMutations = [];
+        !base[draftId] && base[publishedId] && baseMutations.push({ create: { ...base[publishedId], _id: draftId } });
+        const baseBefore = base[draftId] ?? base[publishedId];
+        userPatches && baseMutations.push(...userPatches), base = processMutations({
+          documents: base,
+          transactionId,
+          mutations: baseMutations,
+          timestamp
+        });
+        const baseAfter = base[draftId], patches = diffPatch(baseBefore, baseAfter), workingMutations = [];
+        if (!working[draftId] && working[publishedId]) {
+          const newDraftFromPublished = { ...working[publishedId], _id: draftId };
+          if (!checkGrant(grants.create, newDraftFromPublished))
+            throw new PermissionActionError({
+              documentId,
+              transactionId,
+              message: "You do not have permission to create a draft for editing this document."
+            });
+          workingMutations.push({ create: newDraftFromPublished });
+        }
+        const workingBefore = working[draftId] ?? working[publishedId];
+        if (!checkGrant(grants.update, workingBefore))
+          throw new PermissionActionError({
+            documentId,
+            transactionId,
+            message: `You do not have permission to edit document "${documentId}".`
+          });
+        workingMutations.push(...patches.map((patch) => ({ patch: { id: draftId, ...patch } }))), working = processMutations({
+          documents: working,
+          transactionId,
+          mutations: workingMutations,
+          timestamp
+        }), outgoingMutations.push(...workingMutations), outgoingActions.push(
+          ...patches.map(
+            (patch) => ({
+              actionType: "sanity.action.document.edit",
+              draftId,
+              publishedId,
+              patch
+            })
+          )
+        );
+        continue;
+      }
+      case "document.publish": {
+        const documentId = getId(action.documentId), draftId = getDraftId(documentId), publishedId = getPublishedId(documentId), workingDraft = working[draftId], baseDraft = base[draftId];
+        if (!workingDraft || !baseDraft)
+          throw new ActionError({
+            documentId,
+            transactionId,
+            message: `Cannot publish because no draft version was found for document "${documentId}".`
+          });
+        if (!lodashEs.isEqual(workingDraft, baseDraft))
+          throw new ActionError({
+            documentId,
+            transactionId,
+            message: "Publish aborted: The document has changed elsewhere. Please try again."
+          });
+        const newPublishedFromDraft = { ...strengthenOnPublish(workingDraft), _id: publishedId }, mutations = [
+          { delete: { id: draftId } },
+          { createOrReplace: newPublishedFromDraft }
+        ];
+        if (working[draftId] && !checkGrant(grants.update, working[draftId]))
+          throw new PermissionActionError({
+            documentId,
+            transactionId,
+            message: `Publish failed: You do not have permission to update the draft for "${documentId}".`
+          });
+        if (working[publishedId] && !checkGrant(grants.update, newPublishedFromDraft))
+          throw new PermissionActionError({
+            documentId,
+            transactionId,
+            message: `Publish failed: You do not have permission to update the published version of "${documentId}".`
+          });
+        if (!working[publishedId] && !checkGrant(grants.create, newPublishedFromDraft))
+          throw new PermissionActionError({
+            documentId,
+            transactionId,
+            message: `Publish failed: You do not have permission to publish a new version of "${documentId}".`
+          });
+        base = processMutations({ documents: base, transactionId, mutations, timestamp }), working = processMutations({ documents: working, transactionId, mutations, timestamp }), outgoingMutations.push(...mutations), outgoingActions.push({
+          actionType: "sanity.action.document.publish",
+          draftId,
+          publishedId
+        });
+        continue;
+      }
+      case "document.unpublish": {
+        const documentId = getId(action.documentId), draftId = getDraftId(documentId), publishedId = getPublishedId(documentId);
+        if (!working[publishedId] && !base[publishedId])
+          throw new ActionError({
+            documentId,
+            transactionId,
+            message: `Cannot unpublish because the document "${documentId}" is not currently published.`
+          });
+        const sourceDoc = working[publishedId] ?? base[publishedId], newDraftFromPublished = { ...sourceDoc, _id: draftId }, mutations = [
+          { delete: { id: publishedId } },
+          { createIfNotExists: newDraftFromPublished }
+        ];
+        if (!checkGrant(grants.update, sourceDoc))
+          throw new PermissionActionError({
+            documentId,
+            transactionId,
+            message: `You do not have permission to unpublish the document "${documentId}".`
+          });
+        if (!working[draftId] && !checkGrant(grants.create, newDraftFromPublished))
+          throw new PermissionActionError({
+            documentId,
+            transactionId,
+            message: `You do not have permission to create a draft from the published version of "${documentId}".`
+          });
+        base = processMutations({
+          documents: base,
+          transactionId,
+          mutations: [
+            { delete: { id: publishedId } },
+            { createIfNotExists: { ...base[publishedId] ?? sourceDoc, _id: draftId } }
+          ],
+          timestamp
+        }), working = processMutations({ documents: working, transactionId, mutations, timestamp }), outgoingMutations.push(...mutations), outgoingActions.push({
+          actionType: "sanity.action.document.unpublish",
+          draftId,
+          publishedId
+        });
+        continue;
+      }
+      default:
+        throw new Error(
+          `Unknown action type: "${// @ts-expect-error invalid input
+          action.type}". Please contact support if this issue persists.`
+        );
+    }
+  const previousRevs = Object.fromEntries(
+    Object.entries(initialWorking).map(([id, doc]) => [id, doc?._rev])
+  );
+  return {
+    working,
+    outgoingActions,
+    outgoingMutations,
+    previous: initialWorking,
+    previousRevs
+  };
+}
+function strengthenOnPublish(draft) {
+  const isStrengthenReference = (value) => "_strengthenOnPublish" in value;
+  function strengthen(value) {
+    if (typeof value != "object" || !value) return value;
+    if (isStrengthenReference(value)) {
+      const { _strengthenOnPublish, _weak, ...rest } = value;
+      return {
+        ...rest,
+        ..._strengthenOnPublish.weak && { _weak: !0 }
+      };
+    }
+    return Array.isArray(value) ? value.map(strengthen) : Object.fromEntries(Object.entries(value).map(([k2, v2]) => [k2, strengthen(v2)]));
+  }
+  return strengthen(draft);
+}
+const EMPTY_REVISIONS = {};
+function queueTransaction(prev, transaction) {
+  const { transactionId, actions } = transaction;
+  return {
+    ...getDocumentIdsFromActions(actions).reduce(
+      (acc, id) => addSubscriptionIdToDocument(acc, id, transactionId),
+      prev
+    ),
+    queued: [...prev.queued, transaction]
+  };
+}
+function removeQueuedTransaction(prev, transactionId) {
+  const transaction = prev.queued.find((t2) => t2.transactionId === transactionId);
+  return transaction ? {
+    ...getDocumentIdsFromActions(transaction.actions).reduce(
+      (acc, id) => removeSubscriptionIdFromDocument(acc, id, transactionId),
+      prev
+    ),
+    queued: prev.queued.filter((t2) => transactionId !== t2.transactionId)
+  } : prev;
+}
+function applyFirstQueuedTransaction(prev) {
+  const queued = prev.queued.at(0);
+  if (!queued || !prev.grants) return prev;
+  const ids = getDocumentIdsFromActions(queued.actions);
+  if (ids.some((id) => prev.documentStates[id]?.local === void 0)) return prev;
+  const working = ids.reduce((acc, id) => (acc[id] = prev.documentStates[id]?.local, acc), {}), timestamp = (/* @__PURE__ */ new Date()).toISOString(), result = processActions({
+    ...queued,
+    working,
+    base: working,
+    timestamp,
+    grants: prev.grants
+  }), applied = {
+    ...queued,
+    ...result,
+    base: result.previous,
+    timestamp
+  };
+  return {
+    ...prev,
+    applied: [...prev.applied, applied],
+    queued: prev.queued.filter((t2) => t2.transactionId !== queued.transactionId),
+    documentStates: Object.entries(result.working).reduce(
+      (acc, [id, next]) => {
+        const prevDoc = acc[id];
+        return prevDoc && (acc[id] = { ...prevDoc, local: next }), acc;
+      },
+      { ...prev.documentStates }
+    )
+  };
+}
+function batchAppliedTransactions([curr, ...rest]) {
+  if (!curr) return;
+  if (!curr.actions.length) return batchAppliedTransactions(rest);
+  if (curr.actions.length > 1)
+    return {
+      ...curr,
+      disableBatching: !0,
+      batchedTransactionIds: [curr.transactionId]
+    };
+  const [action] = curr.actions;
+  if (action.type !== "document.edit" || curr.disableBatching)
+    return {
+      ...curr,
+      disableBatching: !0,
+      batchedTransactionIds: [curr.transactionId]
+    };
+  const editAction = {
+    ...curr,
+    actions: [action],
+    disableBatching: !1,
+    batchedTransactionIds: [curr.transactionId]
+  };
+  if (!rest.length) return editAction;
+  const next = batchAppliedTransactions(rest);
+  if (next)
+    return next.disableBatching ? editAction : {
+      disableBatching: !1,
+      // Use the transactionId from the later (next) transaction.
+      transactionId: next.transactionId,
+      // Accumulate actions: current action first, then later ones.
+      actions: [action, ...next.actions],
+      // Merge outgoingActions in order.
+      outgoingActions: [...curr.outgoingActions, ...next.outgoingActions],
+      // Batched transaction IDs: preserve order by placing curr first.
+      batchedTransactionIds: [curr.transactionId, ...next.batchedTransactionIds],
+      // Merge outgoingMutations in order.
+      outgoingMutations: [...curr.outgoingMutations, ...next.outgoingMutations],
+      // Working state reflects the latest optimistic changes: later transactions override earlier.
+      working: { ...curr.working, ...next.working },
+      // Base state (base, previous, previousRevs) must reflect the original state.
+      // Use curr values (the earliest transaction) to override later ones.
+      previousRevs: { ...next.previousRevs, ...curr.previousRevs },
+      previous: { ...next.previous, ...curr.previous },
+      base: { ...next.base, ...curr.base },
+      // Use the earliest timestamp from curr.
+      timestamp: curr.timestamp ?? next.timestamp
+    };
+}
+function transitionAppliedTransactionsToOutgoing(prev) {
+  if (prev.outgoing) return prev;
+  const transaction = batchAppliedTransactions(prev.applied);
+  if (!transaction) return prev;
+  const {
+    transactionId,
+    previousRevs,
+    working,
+    batchedTransactionIds: consumedTransactions
+  } = transaction, timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    ...prev,
+    outgoing: transaction,
+    applied: prev.applied.filter((i2) => !consumedTransactions.includes(i2.transactionId)),
+    documentStates: Object.entries(previousRevs).reduce(
+      (acc, [documentId, previousRev]) => {
+        if (working[documentId]?._rev === previousRev) return acc;
+        const documentState = prev.documentStates[documentId];
+        return documentState && (acc[documentId] = {
+          ...documentState,
+          unverifiedRevisions: {
+            ...documentState.unverifiedRevisions,
+            // add unverified revision
+            [transactionId]: { documentId, previousRev, transactionId, timestamp }
+          }
+        }), acc;
+      },
+      { ...prev.documentStates }
+    )
+  };
+}
+function cleanupOutgoingTransaction(prev) {
+  const { outgoing } = prev;
+  if (!outgoing) return prev;
+  let next = prev;
+  const ids = getDocumentIdsFromActions(outgoing.actions);
+  for (const transactionId of outgoing.batchedTransactionIds)
+    for (const documentId of ids)
+      next = removeSubscriptionIdFromDocument(next, documentId, transactionId);
+  return { ...next, outgoing: void 0 };
+}
+function revertOutgoingTransaction(prev) {
+  if (!prev.grants) return prev;
+  let working = Object.fromEntries(
+    Object.entries(prev.documentStates).map(([documentId, documentState]) => [
+      documentId,
+      documentState?.remote
+    ])
+  );
+  const nextApplied = [];
+  for (const t2 of prev.applied)
+    try {
+      const next = processActions({ ...t2, working, grants: prev.grants });
+      working = next.working, nextApplied.push({ ...t2, ...next });
+    } catch (error) {
+      if (error instanceof ActionError) continue;
+      throw error;
+    }
+  return {
+    ...prev,
+    applied: nextApplied,
+    outgoing: void 0,
+    documentStates: Object.fromEntries(
+      Object.entries(prev.documentStates).filter((e3) => !!e3[1]).map(([documentId, { unverifiedRevisions = {}, local, ...documentState }]) => {
+        const next = {
+          ...documentState,
+          local: documentId in working ? working[documentId] : local,
+          unverifiedRevisions: prev.outgoing && prev.outgoing.transactionId in unverifiedRevisions ? lodashEs.omit(unverifiedRevisions, prev.outgoing.transactionId) : unverifiedRevisions
+        };
+        return [documentId, next];
+      })
+    )
+  };
+}
+function applyRemoteDocument(prev, { document: document2, documentId, previousRev, revision, timestamp, type }, events) {
+  if (!prev.grants) return prev;
+  const prevDocState = prev.documentStates[documentId];
+  if (!prevDocState) return prev;
+  const prevUnverifiedRevisions = prevDocState.unverifiedRevisions, revisionToVerify = revision ? prevUnverifiedRevisions?.[revision] : void 0;
+  let unverifiedRevisions = prevUnverifiedRevisions ?? EMPTY_REVISIONS;
+  if (revision && revisionToVerify && (unverifiedRevisions = lodashEs.omit(prevUnverifiedRevisions, revision)), type === "sync" && (unverifiedRevisions = Object.fromEntries(
+    Object.entries(unverifiedRevisions).filter(([, unverifiedRevision]) => unverifiedRevision ? new Date(timestamp).getTime() <= new Date(unverifiedRevision.timestamp).getTime() : !1)
+  )), revisionToVerify && revisionToVerify.previousRev === previousRev)
+    return {
+      ...prev,
+      documentStates: {
+        ...prev.documentStates,
+        [documentId]: {
+          ...prevDocState,
+          remote: document2,
+          remoteRev: revision,
+          unverifiedRevisions
+        }
+      }
+    };
+  let working = { ...prev.applied.at(0)?.previous, [documentId]: document2 };
+  const nextApplied = [];
+  for (const curr of prev.applied)
+    try {
+      const next = processActions({ ...curr, working, grants: prev.grants });
+      working = next.working, nextApplied.push({ ...curr, ...next });
+    } catch (error) {
+      if (error instanceof ActionError) {
+        events.next({
+          type: "rebase-error",
+          transactionId: error.transactionId,
+          documentId: error.documentId,
+          message: error.message,
+          error
+        });
+        continue;
+      }
+      throw error;
+    }
+  return {
+    ...prev,
+    applied: nextApplied,
+    documentStates: {
+      ...prev.documentStates,
+      [documentId]: {
+        ...prevDocState,
+        remote: document2,
+        remoteRev: revision,
+        local: working[documentId],
+        unverifiedRevisions
+      }
+    }
+  };
+}
+function addSubscriptionIdToDocument(prev, documentId, subscriptionId) {
+  const prevDocState = prev.documentStates?.[documentId], prevSubscriptions = prevDocState?.subscriptions ?? [];
+  return {
+    ...prev,
+    documentStates: {
+      ...prev.documentStates,
+      [documentId]: {
+        ...prevDocState,
+        id: documentId,
+        subscriptions: [...prevSubscriptions, subscriptionId]
+      }
+    }
+  };
+}
+function removeSubscriptionIdFromDocument(prev, documentId, subscriptionId) {
+  const prevDocState = prev.documentStates?.[documentId], subscriptions = (prevDocState?.subscriptions ?? []).filter((id) => id !== subscriptionId);
+  return prevDocState ? subscriptions.length ? {
+    ...prev,
+    documentStates: {
+      ...prev.documentStates,
+      [documentId]: { ...prevDocState, subscriptions }
+    }
+  } : { ...prev, documentStates: lodashEs.omit(prev.documentStates, documentId) } : prev;
+}
+function manageSubscriberIds(state, documentId) {
+  const documentIds = Array.from(
+    new Set(
+      (Array.isArray(documentId) ? documentId : [documentId]).flatMap((id) => [
+        csm.getPublishedId(id),
+        getDraftId(id)
+      ])
+    )
+  ), subscriptionId = insecureRandomId();
+  return state.set(
+    "addSubscribers",
+    (prev) => documentIds.reduce(
+      (acc, id) => addSubscriptionIdToDocument(acc, id, subscriptionId),
+      prev
+    )
+  ), () => {
+    setTimeout(() => {
+      state.set(
+        "removeSubscribers",
+        (prev) => documentIds.reduce(
+          (acc, id) => removeSubscriptionIdFromDocument(acc, id, subscriptionId),
+          prev
+        )
+      );
+    }, DOCUMENT_STATE_CLEAR_DELAY);
+  };
+}
+function getDocumentIdsFromActions(action) {
+  const actions = Array.isArray(action) ? action : [action];
+  return Array.from(
+    new Set(
+      actions.map((i2) => i2.documentId).filter((i2) => typeof i2 == "string").flatMap((documentId) => [csm.getPublishedId(documentId), getDraftId(documentId)])
+    )
+  );
+}
+function getDocumentEvents(outgoing) {
+  const documentIdsByAction = Object.entries(
+    outgoing.actions.reduce(
+      (acc, { type, documentId }) => {
+        const ids = acc[type] || /* @__PURE__ */ new Set();
+        return documentId && ids.add(documentId), acc[type] = ids, acc;
+      },
+      {}
+    )
+  ), actionMap = {
+    "document.create": "created",
+    "document.delete": "deleted",
+    "document.discard": "discarded",
+    "document.edit": "edited",
+    "document.publish": "published",
+    "document.unpublish": "unpublished"
+  };
+  return documentIdsByAction.flatMap(
+    ([actionType, documentIds]) => Array.from(documentIds).map(
+      (documentId) => ({ type: actionMap[actionType], documentId, outgoing })
+    )
+  );
+}
+const API_VERSION$1 = "vX";
+function createSharedListener(instance) {
+  const events$ = getClientState(instance, { apiVersion: API_VERSION$1 }).observable.pipe(
+    rxjs.switchMap(
+      (client2) => (
+        // TODO: it seems like the client.listen method is not emitting disconnected
+        // events. this is important to ensure we have an up to date version of the
+        // doc. probably should introduce our own events for when the user goes offline
+        client2.listen(
+          "*",
+          {},
+          {
+            events: ["mutation", "welcome", "reconnect"],
+            includeResult: !1,
+            tag: "document-listener"
+            // // from manual testing, it seems like mendoza patches may be
+            // // causing some ambiguity/wonkiness
+            // includeMutations: false,
+            // effectFormat: 'mendoza',
+          }
+        )
+      )
+    ),
+    rxjs.share()
+  ), [welcome$, mutation$] = rxjs.partition(events$, (e3) => e3.type === "welcome");
+  return rxjs.merge(
+    // we replay the welcome event because that event kicks off fetching the document
+    welcome$.pipe(rxjs.shareReplay(1)),
+    mutation$
+  );
+}
+function createFetchDocument(instance) {
+  return function(documentId) {
+    return getClientState(instance, { apiVersion: API_VERSION$1 }).observable.pipe(
+      rxjs.switchMap((client2) => _unstable_store.createDocumentLoaderFromClient(client2)(documentId)),
+      rxjs.map((result) => {
+        if (!result.accessible) {
+          if (result.reason === "existence") return null;
+          throw new Error(`Document with ID \`${documentId}\` is inaccessible due to permissions.`);
+        }
+        return result.document;
+      }),
+      rxjs.first()
+    );
+  };
+}
+const documentStore = {
+  name: "Document",
+  getInitialState: (instance) => ({
+    documentStates: {},
+    // these can be emptied on refetch
+    queued: [],
+    applied: [],
+    sharedListener: createSharedListener(instance),
+    fetchDocument: createFetchDocument(instance),
+    events: new rxjs.Subject()
+  }),
+  initialize() {
+    const queuedTransactionSubscription = subscribeToQueuedAndApplyNextTransaction(this), subscriptionsSubscription = subscribeToSubscriptionsAndListenToDocuments(this), appliedSubscription = subscribeToAppliedAndSubmitNextTransaction(this), clientSubscription = subscribeToClientAndFetchDatasetAcl(this);
+    return () => {
+      queuedTransactionSubscription.unsubscribe(), subscriptionsSubscription.unsubscribe(), appliedSubscription.unsubscribe(), clientSubscription.unsubscribe();
+    };
+  }
+};
+function getDocumentState(...args) {
+  return _getDocumentState(...args);
+}
+const _getDocumentState = createStateSourceAction(documentStore, {
+  selector: ({ error, documentStates }, doc, path) => {
+    const documentId = typeof doc == "string" ? doc : doc._id;
+    if (error) throw error;
+    const draftId = getDraftId(documentId), publishedId = csm.getPublishedId(documentId), draft = documentStates[draftId]?.local, published = documentStates[publishedId]?.local, document2 = draft ?? published;
+    if (document2 !== void 0)
+      return path ? jsonMatch(document2, path).at(0)?.value : document2;
+  },
+  onSubscribe: ({ state }, doc) => manageSubscriberIds(state, typeof doc == "string" ? doc : doc._id)
+});
+function resolveDocument(...args) {
+  return _resolveDocument(...args);
+}
+const _resolveDocument = createAction(documentStore, () => function(doc) {
+  const documentId = typeof doc == "string" ? doc : doc._id;
+  return rxjs.firstValueFrom(
+    getDocumentState(this, documentId).observable.pipe(rxjs.filter((i2) => i2 !== void 0))
+  );
+}), getDocumentSyncStatus = createStateSourceAction(documentStore, {
+  selector: ({ error, documentStates: documents, outgoing, applied, queued }, doc) => {
+    const documentId = doc._id;
+    if (error) throw error;
+    const draftId = getDraftId(documentId), publishedId = csm.getPublishedId(documentId), draft = documents[draftId], published = documents[publishedId];
+    if (!(draft === void 0 || published === void 0))
+      return !queued.length && !applied.length && !outgoing;
+  },
+  onSubscribe: ({ state }, doc) => manageSubscriberIds(state, doc._id)
+}), getPermissionsState = createStateSourceAction(documentStore, {
+  selector: calculatePermissions,
+  onSubscribe: ({ state }, actions) => manageSubscriberIds(state, getDocumentIdsFromActions(actions))
+}), resolvePermissions = createAction(documentStore, () => function(actions) {
+  return rxjs.firstValueFrom(
+    getPermissionsState(this, actions).observable.pipe(rxjs.filter((i2) => i2 !== void 0))
+  );
+}), subscribeDocumentEvents = createAction(documentStore, ({ state }) => {
+  const { events } = state.get();
+  return function(eventHandler) {
+    const subscription = events.subscribe(eventHandler);
+    return () => subscription.unsubscribe();
+  };
+}), subscribeToQueuedAndApplyNextTransaction = createInternalAction(
+  ({ state }) => {
+    const { events } = state.get();
+    return function() {
+      return state.observable.pipe(
+        rxjs.map(applyFirstQueuedTransaction),
+        rxjs.distinctUntilChanged(),
+        rxjs.tap((next) => state.set("applyFirstQueuedTransaction", next)),
+        rxjs.catchError((error, caught) => {
+          if (error instanceof ActionError)
+            return state.set(
+              "removeQueuedTransaction",
+              (prev) => removeQueuedTransaction(prev, error.transactionId)
+            ), events.next({
+              type: "error",
+              message: error.message,
+              documentId: error.documentId,
+              transactionId: error.transactionId,
+              error
+            }), caught;
+          throw error;
+        })
+      ).subscribe({ error: (error) => state.set("setError", { error }) });
+    };
+  }
+), subscribeToAppliedAndSubmitNextTransaction = createInternalAction(
+  ({ state, instance }) => {
+    const { events } = state.get();
+    return function() {
+      return state.observable.pipe(
+        rxjs.throttle(
+          (s2) => (
+            // if there is no outgoing transaction, we can throttle by the
+            // initial outgoing throttle time…
+            s2.outgoing ? (
+              // …otherwise, wait until the outgoing has been cleared
+              state.observable.pipe(rxjs.first(({ outgoing }) => !outgoing))
+            ) : rxjs.timer(INITIAL_OUTGOING_THROTTLE_TIME)
+          ),
+          { leading: !1, trailing: !0 }
+        ),
+        rxjs.map(transitionAppliedTransactionsToOutgoing),
+        rxjs.distinctUntilChanged((a2, b2) => a2.outgoing?.transactionId === b2.outgoing?.transactionId),
+        rxjs.tap((next) => state.set("transitionAppliedTransactionsToOutgoing", next)),
+        rxjs.map((s2) => s2.outgoing),
+        rxjs.distinctUntilChanged(),
+        rxjs.withLatestFrom(getClientState(instance, { apiVersion: API_VERSION$2 }).observable),
+        rxjs.concatMap(([outgoing, client2]) => outgoing ? client2.observable.action(outgoing.outgoingActions, {
+          transactionId: outgoing.transactionId,
+          skipCrossDatasetReferenceValidation: !0
+        }).pipe(
+          rxjs.catchError((error) => (state.set("revertOutgoingTransaction", revertOutgoingTransaction), events.next({ type: "reverted", message: error.message, outgoing, error }), rxjs.EMPTY)),
+          rxjs.map((result) => ({ result, outgoing }))
+        ) : rxjs.EMPTY),
+        rxjs.tap(({ outgoing, result }) => {
+          state.set("cleanupOutgoingTransaction", cleanupOutgoingTransaction);
+          for (const e3 of getDocumentEvents(outgoing)) events.next(e3);
+          events.next({ type: "accepted", outgoing, result });
+        })
+      ).subscribe({ error: (error) => state.set("setError", { error }) });
+    };
+  }
+), subscribeToSubscriptionsAndListenToDocuments = createInternalAction(
+  ({ state }) => {
+    const { events } = state.get();
+    return function() {
+      return state.observable.pipe(
+        rxjs.filter((s2) => !!s2.grants),
+        rxjs.map((s2) => Object.keys(s2.documentStates)),
+        rxjs.distinctUntilChanged((curr, next) => {
+          if (curr.length !== next.length) return !1;
+          const currSet = new Set(curr);
+          return next.every((i2) => currSet.has(i2));
+        }),
+        rxjs.startWith(/* @__PURE__ */ new Set()),
+        rxjs.pairwise(),
+        rxjs.switchMap((pair) => {
+          const [curr, next] = pair.map((ids) => new Set(ids)), added = Array.from(next).filter((i2) => !curr.has(i2)), removed = Array.from(curr).filter((i2) => !next.has(i2)), changes = [
+            ...added.map((id) => ({ id, add: !0 })),
+            ...removed.map((id) => ({ id, add: !1 }))
+          ].sort((a2, b2) => {
+            const aIsDraft = a2.id === getDraftId(a2.id), bIsDraft = b2.id === getDraftId(b2.id);
+            return aIsDraft && bIsDraft ? a2.id.localeCompare(b2.id, "en-US") : aIsDraft ? -1 : bIsDraft ? 1 : a2.id.localeCompare(b2.id, "en-US");
+          });
+          return rxjs.of(...changes);
+        }),
+        rxjs.groupBy((i2) => i2.id),
+        rxjs.mergeMap(
+          (group) => group.pipe(
+            rxjs.switchMap((e3) => e3.add ? listen(this, e3.id).pipe(
+              rxjs.catchError((error) => {
+                throw error instanceof OutOfSyncError && listen(this, e3.id), error;
+              }),
+              rxjs.tap(
+                (remote) => state.set(
+                  "applyRemoteDocument",
+                  (prev) => applyRemoteDocument(prev, remote, events)
+                )
+              )
+            ) : rxjs.EMPTY)
+          )
+        )
+      ).subscribe({ error: (error) => state.set("setError", { error }) });
+    };
+  }
+), subscribeToClientAndFetchDatasetAcl = createInternalAction(
+  ({ instance, state }) => {
+    const { projectId, dataset } = instance.identity;
+    return function() {
+      return getClientState(instance, { apiVersion: API_VERSION$2 }).observable.pipe(
+        rxjs.switchMap(
+          (client2) => client2.observable.request({
+            uri: `/projects/${projectId}/datasets/${dataset}/acl`,
+            tag: "acl.get",
+            withCredentials: !0
+          })
+        ),
+        rxjs.tap((datasetAcl) => state.set("setGrants", { grants: createGrantsLookup(datasetAcl) }))
+      ).subscribe({
+        error: (error) => state.set("setError", { error })
+      });
+    };
+  }
+);
+function applyDocumentActions(...args) {
+  return _applyDocumentActions(...args);
+}
+const _applyDocumentActions = createAction(documentStore, ({ state }) => {
+  const { events } = state.get();
+  return async function(action, { transactionId = crypto.randomUUID(), disableBatching } = {}) {
+    const actions = Array.isArray(action) ? action : [action], transaction = {
+      transactionId,
+      actions,
+      ...disableBatching && { disableBatching }
+    }, fatalError$ = state.observable.pipe(
+      rxjs.map((s2) => s2.error),
+      rxjs.first(Boolean),
+      rxjs.map((error) => ({ type: "error", error }))
+    ), transactionError$ = events.pipe(
+      rxjs.filter((e3) => e3.type === "error"),
+      rxjs.first((e3) => e3.transactionId === transactionId)
+    ), appliedTransaction$ = state.observable.pipe(
+      rxjs.map((s2) => s2.applied),
+      rxjs.distinctUntilChanged(),
+      rxjs.map((applied) => applied.find((t2) => t2.transactionId === transactionId)),
+      rxjs.first(Boolean)
+    ), successfulTransaction$ = events.pipe(
+      rxjs.filter((e3) => e3.type === "accepted"),
+      rxjs.first((e3) => e3.outgoing.batchedTransactionIds.includes(transactionId))
+    ), rejectedTransaction$ = events.pipe(
+      rxjs.filter((e3) => e3.type === "reverted"),
+      rxjs.first((e3) => e3.outgoing.batchedTransactionIds.includes(transactionId))
+    ), appliedTransactionOrError = rxjs.firstValueFrom(
+      rxjs.race([fatalError$, transactionError$, appliedTransaction$])
+    ), acceptedOrRejectedTransaction = rxjs.firstValueFrom(
+      rxjs.race([successfulTransaction$, rejectedTransaction$, transactionError$])
+    );
+    state.set("queueTransaction", (prev) => queueTransaction(prev, transaction));
+    const result = await appliedTransactionOrError;
+    if ("type" in result && result.type === "error") throw result.error;
+    const { working: documents, previous, previousRevs } = result, existingIds = new Set(
+      Object.entries(previous).filter(([, value]) => !!value).map(([key]) => key)
+    ), resultingIds = new Set(
+      Object.entries(documents).filter(([, value]) => !!value).map(([key]) => key)
+    ), allIds = /* @__PURE__ */ new Set([...existingIds, ...resultingIds]), updated = [], appeared = [], disappeared = [];
+    for (const id of allIds)
+      existingIds.has(id) && resultingIds.has(id) ? updated.push(id) : !existingIds.has(id) && resultingIds.has(id) ? appeared.push(id) : !resultingIds.has(id) && existingIds.has(id) && disappeared.push(id);
+    async function submitted() {
+      const raceResult = await acceptedOrRejectedTransaction;
+      if (raceResult.type !== "accepted") throw raceResult.error;
+      return raceResult.result;
+    }
+    return {
+      transactionId,
+      documents,
+      previous,
+      previousRevs,
+      appeared,
+      updated,
+      disappeared,
+      submitted
+    };
+  };
+});
+function getSdkIdentity({
+  projectId,
+  dataset
+}) {
+  const id = generateId();
+  return Object.freeze({
+    id,
+    projectId,
+    dataset,
+    resourceId: `${projectId}.${dataset}`
+  });
+}
+function generateId() {
+  return Array.from(
+    { length: 8 },
+    () => Math.floor(Math.random() * 16).toString(16).padStart(2, "0")
+  ).join("");
+}
+function createSanityInstance({
+  projectId = "",
+  dataset = "",
+  ...config
+}) {
+  const identity = getSdkIdentity({ projectId, dataset });
+  return {
+    identity,
+    config,
+    dispose: () => disposeResources(identity)
+  };
+}
+function createLiveEventSubscriber(tag) {
+  return createInternalAction(({ instance, state }) => {
+    const client$ = getClientState(instance, { apiVersion: "vX" }).observable, syncTags$ = state.observable.pipe(
+      rxjs.map((i2) => i2.syncTags),
+      rxjs.distinctUntilChanged()
+    );
+    return function() {
+      const messageEvents$ = client$.pipe(
+        rxjs.switchMap(
+          (client2) => client2.live.events({ includeDrafts: !!client2.config().token, tag }).pipe(rxjs.filter((e3) => e3.type === "message"))
+        )
+      );
+      return rxjs.combineLatest([messageEvents$, syncTags$]).subscribe({
+        next: ([event, currentSyncTags]) => {
+          for (const eventTag of event.tags)
+            if (currentSyncTags[eventTag]) {
+              state.set("setLastLiveEventId", (prevState) => ({
+                ...prevState,
+                lastLiveEventId: event.id
+              }));
+              return;
+            }
+        }
+      });
+    };
+  });
+}
+function hashString(str) {
+  let hash = 0;
+  for (let i2 = 0; i2 < str.length; i2++)
+    hash = (hash * 31 + str.charCodeAt(i2)) % 2147483647;
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+const TITLE_CANDIDATES = ["title", "name", "label", "heading", "header", "caption"], SUBTITLE_CANDIDATES = ["description", "subtitle", ...TITLE_CANDIDATES];
+function getPreviewProjection() {
+  return `{
+    // Get all potential title fields
+    "titleCandidates": {
+      ${TITLE_CANDIDATES.map((field) => `"${field}": ${field}`).join(`,
+      `)}
+    },
+    // Get all potential subtitle fields
+    "subtitleCandidates": {
+      ${SUBTITLE_CANDIDATES.map((field) => `"${field}": ${field}`).join(`,
+      `)}
+    },
+    "media": coalesce(
+      select(
+        defined(asset) => {"type": "image-asset", "_ref": asset._ref},
+        defined(image.asset) => {"type": "image-asset", "_ref": image.asset._ref},
+        defined(mainImage.asset) => {"type": "image-asset", "_ref": mainImage.asset._ref},
+        null
+      )
+    ),
+    _type,
+    _id,
+    _updatedAt
+  }`;
+}
+const PREVIEW_TAG = "preview", STABLE_EMPTY_PREVIEW = { data: null, isPending: !1 }, STABLE_ERROR_PREVIEW = {
+  data: {
+    title: "Preview Error",
+    ...!!getEnv("DEV") && { subtitle: "Check the console for more details" }
+  },
+  isPending: !1
+};
+function assetIdToUrl(assetId, projectId, dataset) {
+  const pattern = /^image-(?<assetName>[A-Za-z0-9]+)-(?<dimensions>\d+x\d+)-(?<format>[a-z]+)$/, match = assetId.match(pattern);
+  if (!match?.groups)
+    throw new Error(
+      `Invalid asset ID \`${assetId}\`. Expected: image-{assetName}-{width}x{height}-{format}`
+    );
+  const { assetName, dimensions, format } = match.groups;
+  return `https://cdn.sanity.io/images/${projectId}/${dataset}/${assetName}-${dimensions}.${format}`;
+}
+function hasImageRef(value) {
+  return lodashEs.isObject(value) && "_ref" in value && typeof value._ref == "string";
+}
+function normalizeMedia(media, projectId, dataset) {
+  return !media || !hasImageRef(media) ? null : {
+    type: "image-asset",
+    _ref: media._ref,
+    url: assetIdToUrl(media._ref, projectId, dataset)
+  };
+}
+function findFirstDefined(fieldsToSearch, candidates, exclude) {
+  if (candidates)
+    for (const field of fieldsToSearch) {
+      const value = candidates[field];
+      if (typeof value == "string" && value.trim() !== "" && value !== exclude)
+        return value;
+    }
+}
+function processPreviewQuery({
+  projectId,
+  dataset,
+  ids,
+  results
+}) {
+  const resultMap = results.reduce((acc, next) => (acc[next._id] = next, acc), {});
+  return Object.fromEntries(
+    Array.from(ids).map((id) => {
+      const publishedId = getPublishedId(id), draftId = getDraftId(id), draftResult = resultMap[draftId], publishedResult = resultMap[publishedId];
+      if (!draftResult && !publishedResult) return [id, STABLE_EMPTY_PREVIEW];
+      try {
+        const result = draftResult || publishedResult;
+        if (!result) return [id, STABLE_EMPTY_PREVIEW];
+        const title = findFirstDefined(TITLE_CANDIDATES, result.titleCandidates), subtitle = findFirstDefined(SUBTITLE_CANDIDATES, result.subtitleCandidates, title), preview = {
+          title: String(title || `${result._type}: ${result._id}`),
+          subtitle: subtitle || void 0,
+          media: normalizeMedia(result.media, projectId, dataset)
+        }, status = {
+          ...draftResult?._updatedAt && { lastEditedDraftAt: draftResult._updatedAt },
+          ...publishedResult?._updatedAt && { lastEditedPublishedAt: publishedResult._updatedAt }
+        };
+        return [id, { data: { ...preview, status }, isPending: !1 }];
+      } catch (e3) {
+        return console.warn(e3), [id, STABLE_ERROR_PREVIEW];
+      }
+    })
+  );
+}
+function createPreviewQuery(documentIds) {
+  const allIds = Array.from(documentIds).flatMap((id) => [getPublishedId(id), getDraftId(id)]), projection = getPreviewProjection(), queryHash = hashString(projection);
+  return {
+    query: `*[_id in $__ids_${queryHash}]${projection}`,
+    params: {
+      [`__ids_${queryHash}`]: allIds
+    }
+  };
+}
+const BATCH_DEBOUNCE_TIME$1 = 50, subscribeToStateAndFetchBatches$1 = createInternalAction(
+  ({ state, instance }) => function() {
+    const client$ = getClientState(instance, { apiVersion: "vX" }).observable, documentTypes$ = state.observable.pipe(
+      rxjs.map((i2) => i2.documentTypes),
+      rxjs.distinctUntilChanged()
+    ), lastLiveEventId$ = state.observable.pipe(
+      rxjs.map((i2) => i2.lastLiveEventId),
+      rxjs.distinctUntilChanged()
+    ), newSubscriberIds$ = state.observable.pipe(
+      rxjs.map(({ subscriptions }) => new Set(Object.keys(subscriptions))),
+      rxjs.distinctUntilChanged(
+        (a2, b2) => a2.size !== b2.size ? !1 : Array.from(a2).every((i2) => b2.has(i2))
+      ),
+      rxjs.debounceTime(BATCH_DEBOUNCE_TIME$1),
+      rxjs.startWith(/* @__PURE__ */ new Set()),
+      rxjs.pairwise(),
+      rxjs.tap(([prevIds, currIds]) => {
+        const newIds = [...currIds].filter((element) => !prevIds.has(element));
+        state.set("updatingPending", (prev) => {
+          const pendingValues = newIds.reduce((acc, id) => {
+            const prevValue = prev.values[id], value = prevValue?.data ? prevValue.data : null;
+            return acc[id] = { data: value, isPending: !0 }, acc;
+          }, {});
+          return { values: { ...prev.values, ...pendingValues } };
+        });
+      }),
+      rxjs.withLatestFrom(documentTypes$),
+      rxjs.map(([[, ids], documentTypes]) => ({ ids, documentTypes }))
+    );
+    return rxjs.combineLatest([newSubscriberIds$, lastLiveEventId$, client$]).pipe(
+      rxjs.switchMap(([{ ids }, lastLiveEventId, client2]) => {
+        if (!ids.size) return rxjs.EMPTY;
+        const { query, params } = createPreviewQuery(ids);
+        return client2.observable.fetch(query, params, {
+          filterResponse: !1,
+          returnQuery: !1,
+          perspective: "drafts",
+          tag: PREVIEW_TAG,
+          lastLiveEventId
+        }).pipe(rxjs.map((response) => ({ ...response, ids })));
+      }),
+      rxjs.map(({ ids, result, syncTags }) => ({
+        syncTags,
+        values: processPreviewQuery({
+          projectId: instance.identity.projectId,
+          dataset: instance.identity.dataset,
+          ids,
+          results: result
+        })
+      }))
+    ).subscribe({
+      next: ({ syncTags = [], values }) => {
+        state.set("updateResult", (prev) => ({
+          values: { ...prev.values, ...values },
+          syncTags: syncTags.reduce((acc, next) => (acc[next] = !0, acc), {})
+        }));
+      }
+    });
+  }
+), previewStore = {
+  name: "Preview",
+  getInitialState() {
+    return {
+      documentTypes: {},
+      lastLiveEventId: null,
+      subscriptions: {},
+      syncTags: {},
+      values: {}
+    };
+  },
+  initialize() {
+    const subscribeToLiveAndSetLastLiveEventId = createLiveEventSubscriber(PREVIEW_TAG), stateSubscriptionForBatches = subscribeToStateAndFetchBatches$1(this), liveSubscription = subscribeToLiveAndSetLastLiveEventId(this);
+    return () => {
+      stateSubscriptionForBatches.unsubscribe(), liveSubscription.unsubscribe();
+    };
+  }
+}, _getPreviewState = createStateSourceAction(
+  previewStore,
+  (state, { document: document2 }) => state.values[document2._id] ?? STABLE_EMPTY_PREVIEW
+), getPreviewState = createAction(previewStore, ({ state }) => function({ document: document2 }) {
+  const { _id, _type: documentType } = document2, documentId = getPublishedId(_id), previewState = _getPreviewState(this, { document: document2 });
+  return {
+    ...previewState,
+    subscribe: (subscriber) => {
+      const subscriptionId = insecureRandomId();
+      state.set("addSubscription", (prev) => ({
+        documentTypes: {
+          ...prev.documentTypes,
+          [documentId]: documentType
+        },
+        subscriptions: {
+          ...prev.subscriptions,
+          [documentId]: {
+            ...prev.subscriptions[documentId],
+            [subscriptionId]: !0
+          }
+        }
+      }));
+      const unsubscribe = previewState.subscribe(subscriber);
+      return () => {
+        unsubscribe(), state.set("removeSubscription", (prev) => {
+          const documentSubscriptions = lodashEs.omit(prev.subscriptions[documentId], subscriptionId), hasSubscribers = !!Object.keys(documentSubscriptions).length, prevValue = prev.values[documentId], previewValue = prevValue?.data ? prevValue.data : null;
+          return {
+            subscriptions: hasSubscribers ? { ...prev.subscriptions, [documentId]: documentSubscriptions } : lodashEs.omit(prev.subscriptions, documentId),
+            values: hasSubscribers ? prev.values : { ...prev.values, [documentId]: { data: previewValue, isPending: !1 } }
+          };
+        });
+      };
+    }
+  };
+}), resolvePreview = createAction(previewStore, () => function({ document: document2 }) {
+  const { getCurrent, subscribe } = getPreviewState(this, { document: document2 });
+  return new Promise((resolve) => {
+    const unsubscribe = subscribe(() => {
+      const current = getCurrent();
+      current?.data && (resolve(current), unsubscribe());
+    });
+  });
+}), project = createFetcherStore({
+  name: "Project",
+  getKey: (projectId) => projectId,
+  fetcher: (instance) => (projectId) => getClientState(instance, { apiVersion: "vX", scope: "global" }).observable.pipe(
+    rxjs.switchMap((client2) => client2.observable.projects.getById(projectId))
+  )
+}), getProjectState = project.getState, resolveProject = project.resolveState, PROJECTION_TAG = "sdk.projection", STABLE_EMPTY_PROJECTION = {
+  data: null,
+  isPending: !1
+};
+function validateProjection(projection) {
+  if (!projection.startsWith("{") || !projection.endsWith("}"))
+    throw new Error(
+      `Invalid projection format: "${projection}". Projections must be enclosed in curly braces, e.g. "{title, 'author': author.name}"`
+    );
+  return projection;
+}
+function createProjectionQuery(documentIds, documentProjections) {
+  const projections = Array.from(documentIds).filter((id) => documentProjections[id]).map((id) => {
+    const projection = validateProjection(documentProjections[id]), projectionHash = hashString(projection);
+    return { documentId: id, projection, projectionHash };
+  }).reduce((acc, { documentId, projection, projectionHash }) => {
+    const obj = acc[projectionHash] ?? { documentIds: /* @__PURE__ */ new Set(), projection };
+    return obj.documentIds.add(documentId), acc[projectionHash] = obj, acc;
+  }, {}), query = `[${Object.entries(projections).map(([projectionHash, { projection }]) => `...*[_id in $__ids_${projectionHash}]{_id,_type,_updatedAt,"result":{...${projection}}}`).join(",")}]`, params = Object.fromEntries(
+    Object.entries(projections).map(([projectionHash, value]) => {
+      const idsInProjection = Array.from(value.documentIds).flatMap((id) => [
+        getPublishedId(id),
+        getDraftId(id)
+      ]);
+      return [`__ids_${projectionHash}`, Array.from(idsInProjection)];
+    })
+  );
+  return { query, params };
+}
+function processProjectionQuery({ ids, results }) {
+  const resultMap = results.reduce(
+    (acc, next) => (acc[next._id] = next, acc),
+    {}
+  );
+  return Object.fromEntries(
+    Array.from(ids).map((id) => {
+      const publishedId = getPublishedId(id), draftId = getDraftId(id), draftResult = resultMap[draftId], publishedResult = resultMap[publishedId], projectionResult = draftResult?.result ?? publishedResult?.result;
+      if (!projectionResult) return [id, { data: null, isPending: !1 }];
+      const status = {
+        ...draftResult?._updatedAt && { lastEditedDraftAt: draftResult._updatedAt },
+        ...publishedResult?._updatedAt && { lastEditedPublishedAt: publishedResult._updatedAt }
+      };
+      return [id, { data: { ...projectionResult, status }, isPending: !1 }];
+    })
+  );
+}
+const BATCH_DEBOUNCE_TIME = 50, subscribeToStateAndFetchBatches = createInternalAction(
+  ({ state, instance }) => function() {
+    const client$ = new rxjs.Observable(
+      (observer) => getClientState(instance, { apiVersion: "vX" }).observable.subscribe(observer)
+    ), documentProjections$ = state.observable.pipe(
+      rxjs.map((i2) => i2.documentProjections),
+      rxjs.distinctUntilChanged()
+    ), lastLiveEventId$ = state.observable.pipe(
+      rxjs.map((i2) => i2.lastLiveEventId),
+      rxjs.distinctUntilChanged()
+    ), newSubscriberIds$ = state.observable.pipe(
+      rxjs.map(({ subscriptions }) => new Set(Object.keys(subscriptions))),
+      rxjs.distinctUntilChanged(
+        (a2, b2) => a2.size !== b2.size ? !1 : Array.from(a2).every((i2) => b2.has(i2))
+      ),
+      rxjs.debounceTime(BATCH_DEBOUNCE_TIME),
+      rxjs.startWith(/* @__PURE__ */ new Set()),
+      rxjs.pairwise(),
+      rxjs.tap(([prevIds, currIds]) => {
+        const newIds = [...currIds].filter((element) => !prevIds.has(element));
+        state.set("updatingPending", (prev) => {
+          const pendingValues = newIds.reduce((acc, id) => {
+            const prevValue = prev.values[id], value = prevValue?.data ? prevValue.data : null;
+            return acc[id] = { data: value, isPending: !0 }, acc;
+          }, {});
+          return { values: { ...prev.values, ...pendingValues } };
+        });
+      }),
+      rxjs.withLatestFrom(documentProjections$),
+      rxjs.map(([[, ids], documentProjections]) => ({ ids, documentProjections }))
+    );
+    return rxjs.combineLatest([newSubscriberIds$, lastLiveEventId$, client$]).pipe(
+      rxjs.switchMap(([{ ids, documentProjections }, lastLiveEventId, client2]) => {
+        if (!ids.size) return rxjs.EMPTY;
+        const { query, params } = createProjectionQuery(ids, documentProjections);
+        return client2.observable.fetch(query, params, {
+          filterResponse: !1,
+          returnQuery: !1,
+          perspective: "drafts",
+          tag: PROJECTION_TAG,
+          lastLiveEventId
+        }).pipe(rxjs.map((response) => ({ ...response, ids })));
+      }),
+      rxjs.map(({ ids, result, syncTags }) => ({
+        syncTags,
+        values: processProjectionQuery({
+          ids,
+          results: result
+        })
+      }))
+    ).subscribe({
+      next: ({ syncTags = [], values }) => {
+        state.set("updateResult", (prev) => ({
+          values: { ...prev.values, ...values },
+          syncTags: syncTags.reduce((acc, next) => (acc[next] = !0, acc), {})
+        }));
+      }
+    });
+  }
+), projectionStore = {
+  name: "Projection",
+  getInitialState() {
+    return {
+      values: {},
+      documentProjections: {},
+      subscriptions: {},
+      syncTags: {},
+      lastLiveEventId: null
+    };
+  },
+  initialize() {
+    const liveSubscription = createLiveEventSubscriber(PROJECTION_TAG)(this), batchSubscription = subscribeToStateAndFetchBatches(this);
+    return () => {
+      liveSubscription.unsubscribe(), batchSubscription.unsubscribe();
+    };
+  }
+}, getProjectStateSourceAction = createStateSourceAction(
+  projectionStore,
+  (state, { document: document2 }) => state.values[document2._id] ?? STABLE_EMPTY_PROJECTION
+);
+function getProjectionState(...args) {
+  return _getProjectionState(...args);
+}
+const _getProjectionState = createAction(projectionStore, ({ state }) => function({
+  document: document2,
+  projection
+}) {
+  const { _id } = document2, documentId = getPublishedId(_id), projectionState = getProjectStateSourceAction(this, { document: document2, projection });
+  return {
+    ...projectionState,
+    subscribe: (subscriber) => {
+      const subscriptionId = insecureRandomId();
+      state.set("addSubscription", (prev) => ({
+        documentProjections: {
+          ...prev.documentProjections,
+          [documentId]: validateProjection(projection)
+        },
+        subscriptions: {
+          ...prev.subscriptions,
+          [documentId]: {
+            ...prev.subscriptions[documentId],
+            [subscriptionId]: !0
+          }
+        }
+      }));
+      const unsubscribe = projectionState.subscribe(subscriber);
+      return () => {
+        unsubscribe(), state.set("removeSubscription", (prev) => {
+          const documentSubscriptions = lodashEs.omit(prev.subscriptions[documentId], subscriptionId), hasSubscribers = !!Object.keys(documentSubscriptions).length, prevValue = prev.values[documentId], projectionValue = prevValue?.data ? prevValue.data : null;
+          return {
+            subscriptions: hasSubscribers ? { ...prev.subscriptions, [documentId]: documentSubscriptions } : lodashEs.omit(prev.subscriptions, documentId),
+            values: hasSubscribers ? prev.values : { ...prev.values, [documentId]: { data: projectionValue, isPending: !1 } }
+          };
+        });
+      };
+    }
+  };
+}), resolveProjection = createAction(projectionStore, () => function({ document: document2, projection }) {
+  const { getCurrent, subscribe } = getProjectionState(this, { document: document2, projection });
+  return new Promise((resolve) => {
+    const unsubscribe = subscribe(() => {
+      const current = getCurrent();
+      current?.data && (resolve(current), unsubscribe());
+    });
+  });
+}), projects = createFetcherStore({
+  name: "Projects",
+  getKey: () => "projects",
+  fetcher: (instance) => () => getClientState(instance, { apiVersion: "vX", scope: "global" }).observable.pipe(
+    rxjs.switchMap((client2) => client2.observable.projects.list({ includeMembers: !1 }))
+  )
+}), getProjectsState = projects.getState, resolveProjects = projects.resolveState, QUERY_STATE_CLEAR_DELAY = 1e3, setQueryError = (key, error) => (prev) => {
+  const prevQuery = prev.queries[key];
+  return prevQuery ? { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, error } } } : prev;
+}, setQueryData = (key, result, syncTags) => (prev) => {
+  const prevQuery = prev.queries[key];
+  return prevQuery ? {
+    ...prev,
+    queries: { ...prev.queries, [key]: { ...prevQuery, result: result ?? null, syncTags } }
+  } : prev;
+}, setLastLiveEventId = (key, lastLiveEventId) => (prev) => {
+  const prevQuery = prev.queries[key];
+  return prevQuery ? { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, lastLiveEventId } } } : prev;
+}, addSubscriber = (key, subscriptionId) => (prev) => {
+  const prevQuery = prev.queries[key], subscribers = [...prevQuery?.subscribers ?? [], subscriptionId];
+  return { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, subscribers } } };
+}, removeSubscriber = (key, subscriptionId) => (prev) => {
+  const prevQuery = prev.queries[key];
+  if (!prevQuery) return prev;
+  const subscribers = prevQuery.subscribers.filter((id) => id !== subscriptionId);
+  return subscribers.length ? { ...prev, queries: { ...prev.queries, [key]: { ...prevQuery, subscribers } } } : { ...prev, queries: lodashEs.omit(prev.queries, key) };
+}, cancelQuery = (key) => (prev) => {
+  const prevQuery = prev.queries[key];
+  return !prevQuery || prevQuery.subscribers.length ? prev : { ...prev, queries: lodashEs.omit(prev.queries, key) };
+}, initializeQuery = (key) => (prev) => prev.queries[key] ? prev : { ...prev, queries: { ...prev.queries, [key]: { subscribers: [] } } }, EMPTY_ARRAY = [], getQueryKey = (query, options = {}) => JSON.stringify({ query, options }), parseQueryKey = (key) => JSON.parse(key), queryStore = {
+  name: "QueryStore",
+  getInitialState: () => ({ queries: {} }),
+  initialize() {
+    const subscriptions = [
+      listenForNewSubscribersAndFetch(this),
+      listenToLiveClientAndSetLastLiveEventIds(this)
+    ];
+    return () => {
+      for (const subscription of subscriptions)
+        subscription.unsubscribe();
+    };
+  }
+}, errorHandler = createInternalAction(({ state }) => function() {
+  return (error) => state.set("setError", { error });
+}), listenForNewSubscribersAndFetch = createInternalAction(
+  ({ state, instance }) => function() {
+    return state.observable.pipe(
+      rxjs.map((s2) => new Set(Object.keys(s2.queries))),
+      rxjs.distinctUntilChanged((curr, next) => curr.size !== next.size ? !1 : Array.from(next).every((i2) => curr.has(i2))),
+      rxjs.startWith(/* @__PURE__ */ new Set()),
+      rxjs.pairwise(),
+      rxjs.mergeMap(([curr, next]) => {
+        const added = Array.from(next).filter((i2) => !curr.has(i2)), removed = Array.from(curr).filter((i2) => !next.has(i2));
+        return [
+          ...added.map((key) => ({ key, added: !0 })),
+          ...removed.map((key) => ({ key, added: !1 }))
+        ];
+      }),
+      rxjs.groupBy((i2) => i2.key),
+      rxjs.mergeMap(
+        (group$) => group$.pipe(
+          rxjs.switchMap((e3) => {
+            if (!e3.added) return rxjs.EMPTY;
+            const lastLiveEventId$ = state.observable.pipe(
+              rxjs.map((s2) => s2.queries[group$.key]?.lastLiveEventId),
+              rxjs.distinctUntilChanged()
+            ), { query, options: { params, scope, ...options } = {} } = parseQueryKey(group$.key), client$ = getClientState(instance, { apiVersion: "vX", scope }).observable;
+            return rxjs.combineLatest([lastLiveEventId$, client$]).pipe(
+              rxjs.switchMap(
+                ([lastLiveEventId, client2]) => client2.observable.fetch(query, params, {
+                  ...options,
+                  filterResponse: !1,
+                  returnQuery: !1,
+                  lastLiveEventId
+                })
+              )
+            );
+          }),
+          rxjs.catchError((error) => (state.set("setQueryError", setQueryError(group$.key, error)), rxjs.EMPTY)),
+          rxjs.tap(({ result, syncTags }) => {
+            state.set("setQueryData", setQueryData(group$.key, result, syncTags));
+          })
+        )
+      )
+    ).subscribe({ error: errorHandler(this) });
+  }
+), listenToLiveClientAndSetLastLiveEventIds = createInternalAction(
+  ({ state, instance }) => function() {
+    const liveMessages$ = getClientState(instance, { apiVersion: "vX" }).observable.pipe(
+      rxjs.switchMap(
+        (client2) => client2.live.events({ includeDrafts: !!client2.config().token, tag: "query-store" })
+      ),
+      rxjs.share(),
+      rxjs.filter((e3) => e3.type === "message")
+    );
+    return state.observable.pipe(
+      rxjs.mergeMap((s2) => Object.entries(s2.queries)),
+      rxjs.groupBy(([key]) => key),
+      rxjs.mergeMap((group$) => {
+        const syncTags$ = group$.pipe(
+          rxjs.map(([, queryState]) => queryState),
+          rxjs.map((i2) => i2?.syncTags ?? EMPTY_ARRAY),
+          rxjs.distinctUntilChanged()
+        );
+        return rxjs.combineLatest([liveMessages$, syncTags$]).pipe(
+          rxjs.filter(([message, syncTags]) => message.tags.some((tag) => syncTags.includes(tag))),
+          rxjs.tap(([message]) => {
+            state.set("setLastLiveEventId", setLastLiveEventId(group$.key, message.id));
+          })
+        );
+      })
+    ).subscribe({ error: errorHandler(this) });
+  }
+);
+function getQueryState(...args) {
+  return _getQueryState(...args);
+}
+const _getQueryState = createStateSourceAction(queryStore, {
+  selector: (state, query, options) => {
+    if (state.error) throw state.error;
+    const key = getQueryKey(query, options), queryState = state.queries[key];
+    if (queryState?.error) throw queryState.error;
+    return queryState?.result;
+  },
+  onSubscribe: ({ state }, query, options) => {
+    const subscriptionId = insecureRandomId(), key = getQueryKey(query, options);
+    return state.set("addSubscriber", addSubscriber(key, subscriptionId)), () => {
+      setTimeout(
+        () => state.set("removeSubscriber", removeSubscriber(key, subscriptionId)),
+        QUERY_STATE_CLEAR_DELAY
+      );
+    };
+  }
+});
+function resolveQuery(...args) {
+  return _resolveQuery(...args);
+}
+const _resolveQuery = createAction(queryStore, ({ state }) => function(query, { signal, ...options } = {}) {
+  const { getCurrent } = getQueryState(this, query, options), key = getQueryKey(query, options), aborted$ = signal ? new rxjs.Observable((observer) => {
+    const cleanup = () => {
+      signal.removeEventListener("abort", listener);
+    }, listener = () => {
+      observer.error(new DOMException("The operation was aborted.", "AbortError")), observer.complete(), cleanup();
+    };
+    return signal.addEventListener("abort", listener), cleanup;
+  }).pipe(
+    rxjs.catchError((error) => {
+      throw error instanceof Error && error.name === "AbortError" && state.set("cancelQuery", cancelQuery(key)), error;
+    })
+  ) : rxjs.NEVER;
+  state.set("initializeQuery", initializeQuery(key));
+  const resolved$ = state.observable.pipe(
+    rxjs.map(getCurrent),
+    rxjs.first((i2) => i2 !== void 0)
+  );
+  return rxjs.firstValueFrom(rxjs.race([resolved$, aborted$]));
+});
+function createStore(resource, actions) {
+  return function(dependencies) {
+    const instance = "instance" in dependencies ? dependencies.instance : dependencies, { state, dispose } = "state" in dependencies ? { state: dependencies.state, dispose: lodashEs.noop } : initializeResource(instance, resource), boundActions = Object.entries(actions).reduce((acc, [key, action]) => (acc[key] = action.bind(null, { state, instance }), acc), {});
+    return { dispose, ...boundActions };
+  };
+}
+const API_VERSION = "vX", usersStore = {
+  name: "users",
+  getInitialState: () => ({
+    users: [],
+    totalCount: 0,
+    nextCursor: null,
+    hasMore: !1,
+    initialFetchCompleted: !1,
+    options: {
+      resourceType: "",
+      resourceId: "",
+      limit: 100
+    }
+  }),
+  initialize() {
+    return () => {
+    };
+  }
+}, getState = createStateSourceAction(
+  usersStore,
+  reselect.createSelector(
+    [
+      (state) => state.users,
+      (state) => state.totalCount,
+      (state) => state.nextCursor,
+      (state) => state.hasMore,
+      (state) => state.initialFetchCompleted,
+      (state) => state.options
+    ],
+    (users, totalCount, nextCursor, hasMore, initialFetchCompleted, options) => ({
+      users,
+      totalCount,
+      nextCursor,
+      hasMore,
+      options,
+      initialFetchCompleted
+    })
+  )
+), fetchUsers = (instance, params) => {
+  const { resourceType, resourceId, nextCursor, limit = 100 } = params;
+  return getClient(instance, { scope: "global", apiVersion: API_VERSION }).request({
+    method: "GET",
+    uri: `access/${resourceType}/${resourceId}/users`,
+    query: nextCursor ? { nextCursor, limit: limit.toString() } : { limit: limit.toString() },
+    tag: "users"
+  });
+}, loadMore = createAction(usersStore, ({ state, instance }) => async function() {
+  const { users, nextCursor, options } = state.get(), { resourceType, resourceId, limit } = options;
+  if (!resourceType || !resourceId)
+    throw new Error("Resource type and ID are required to load more users");
+  const response = await fetchUsers(instance, { resourceType, resourceId, nextCursor, limit }), allUsers = [...users, ...response.data], hasMore = allUsers.length < response.totalCount;
+  state.set("loadMore", {
+    users: allUsers,
+    totalCount: response.totalCount,
+    nextCursor: response.nextCursor,
+    hasMore
+  });
+}), resolveUsers = createAction(usersStore, ({ state, instance }) => async function() {
+  const { options } = state.get(), { resourceType, resourceId, limit } = options;
+  if (!resourceType || !resourceId)
+    throw new Error("Resource type and ID are required to resolve users");
+  const response = await fetchUsers(instance, { resourceType, resourceId, limit }), hasMore = response.data.length < response.totalCount;
+  return state.set("resolveUsers", {
+    users: response.data,
+    totalCount: response.totalCount,
+    nextCursor: response.nextCursor,
+    hasMore,
+    initialFetchCompleted: !0
+  }), response;
+}), setOptions = createAction(usersStore, ({ state }) => function(options) {
+  state.set("options", {
+    ...state.get(),
+    options: {
+      ...state.get().options,
+      resourceType: options.resourceType,
+      resourceId: options.resourceId
+    }
+  });
+}), createUsersStore = createStore(usersStore, {
+  getState,
+  loadMore,
+  resolveUsers,
+  setOptions
+});
+var version = "0.0.0-chore-react-18-compat.1";
+const CORE_SDK_VERSION = getEnv("PKG_VERSION") || `${version}-development`;
+exports.AuthStateType = AuthStateType;
+exports.CORE_SDK_VERSION = CORE_SDK_VERSION;
+exports.applyDocumentActions = applyDocumentActions;
+exports.createDocument = createDocument;
+exports.createSanityInstance = createSanityInstance;
+exports.createUsersStore = createUsersStore;
+exports.deleteDocument = deleteDocument;
+exports.destroyController = destroyController;
+exports.discardDocument = discardDocument;
+exports.editDocument = editDocument;
+exports.fetchLoginUrls = fetchLoginUrls;
+exports.getAuthState = getAuthState;
+exports.getClient = getClient;
+exports.getClientState = getClientState;
+exports.getCurrentUserState = getCurrentUserState;
+exports.getDashboardOrganizationId = getDashboardOrganizationId;
+exports.getDatasetsState = getDatasetsState;
+exports.getDocumentState = getDocumentState;
+exports.getDocumentSyncStatus = getDocumentSyncStatus;
+exports.getLoginUrlsState = getLoginUrlsState;
+exports.getOrCreateChannel = getOrCreateChannel;
+exports.getOrCreateController = getOrCreateController;
+exports.getOrCreateNode = getOrCreateNode;
+exports.getPermissionsState = getPermissionsState;
+exports.getPreviewState = getPreviewState;
+exports.getProjectState = getProjectState;
+exports.getProjectionState = getProjectionState;
+exports.getProjectsState = getProjectsState;
+exports.getQueryKey = getQueryKey;
+exports.getQueryState = getQueryState;
+exports.getResourceId = getResourceId;
+exports.getTokenState = getTokenState;
+exports.handleAuthCallback = handleAuthCallback;
+exports.jsonMatch = jsonMatch;
+exports.logout = logout;
+exports.parseQueryKey = parseQueryKey;
+exports.publishDocument = publishDocument;
+exports.releaseChannel = releaseChannel;
+exports.releaseNode = releaseNode;
+exports.resolveDatasets = resolveDatasets;
+exports.resolveDocument = resolveDocument;
+exports.resolvePermissions = resolvePermissions;
+exports.resolvePreview = resolvePreview;
+exports.resolveProject = resolveProject;
+exports.resolveProjection = resolveProjection;
+exports.resolveProjects = resolveProjects;
+exports.resolveQuery = resolveQuery;
+exports.subscribeDocumentEvents = subscribeDocumentEvents;
+exports.unpublishDocument = unpublishDocument;
+//# sourceMappingURL=index.cjs.map