@sanity/client 6.11.3 → 6.11.4-canary.0

package/umd/sanityClient.js

@@ -64,7 +64,7 @@
   var trim = function(string) {
     return string.replace(/^\s+|\s+$/g, '');
   }
-    , isArray = function(arg) {
+    , isArray$3 = function(arg) {
         return Object.prototype.toString.call(arg) === '[object Array]';
       };
 
@@ -84,7 +84,7 @@
 
       if (typeof(result[key]) === 'undefined') {
         result[key] = value;
-      } else if (isArray(result[key])) {
+      } else if (isArray$3(result[key])) {
         result[key].push(value);
       } else {
         result[key] = [ result[key], value ];
@@ -1464,6 +1464,44 @@
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
   }
 
+  function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  }
+
+  function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+  }
+
   function __values(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
     if (m) return m.call(o);
@@ -1503,6 +1541,30 @@
     return to.concat(ar || Array.prototype.slice.call(from));
   }
 
+  function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+  }
+
+  function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+  }
+
+  function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+  }
+
   typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
@@ -1884,6 +1946,13 @@
       return x;
   }
 
+  function pipe() {
+      var fns = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+          fns[_i] = arguments[_i];
+      }
+      return pipeFromArray(fns);
+  }
   function pipeFromArray(fns) {
       if (fns.length === 0) {
           return identity;
@@ -2067,6 +2136,348 @@
       return OperatorSubscriber;
   }(Subscriber));
 
+  function last(arr) {
+      return arr[arr.length - 1];
+  }
+  function popResultSelector(args) {
+      return isFunction(last(args)) ? args.pop() : undefined;
+  }
+
+  var isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });
+
+  function isPromise(value) {
+      return isFunction(value === null || value === void 0 ? void 0 : value.then);
+  }
+
+  function isInteropObservable(input) {
+      return isFunction(input[observable]);
+  }
+
+  function isAsyncIterable(obj) {
+      return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+  }
+
+  function createInvalidObservableTypeError(input) {
+      return new TypeError("You provided " + (input !== null && typeof input === 'object' ? 'an invalid object' : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+  }
+
+  function getSymbolIterator() {
+      if (typeof Symbol !== 'function' || !Symbol.iterator) {
+          return '@@iterator';
+      }
+      return Symbol.iterator;
+  }
+  var iterator = getSymbolIterator();
+
+  function isIterable(input) {
+      return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
+  }
+
+  function readableStreamLikeToAsyncGenerator(readableStream) {
+      return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
+          var reader, _a, value, done;
+          return __generator(this, function (_b) {
+              switch (_b.label) {
+                  case 0:
+                      reader = readableStream.getReader();
+                      _b.label = 1;
+                  case 1:
+                      _b.trys.push([1, , 9, 10]);
+                      _b.label = 2;
+                  case 2:
+                      return [4, __await(reader.read())];
+                  case 3:
+                      _a = _b.sent(), value = _a.value, done = _a.done;
+                      if (!done) return [3, 5];
+                      return [4, __await(void 0)];
+                  case 4: return [2, _b.sent()];
+                  case 5: return [4, __await(value)];
+                  case 6: return [4, _b.sent()];
+                  case 7:
+                      _b.sent();
+                      return [3, 2];
+                  case 8: return [3, 10];
+                  case 9:
+                      reader.releaseLock();
+                      return [7];
+                  case 10: return [2];
+              }
+          });
+      });
+  }
+  function isReadableStreamLike(obj) {
+      return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
+  }
+
+  function innerFrom(input) {
+      if (input instanceof Observable) {
+          return input;
+      }
+      if (input != null) {
+          if (isInteropObservable(input)) {
+              return fromInteropObservable(input);
+          }
+          if (isArrayLike(input)) {
+              return fromArrayLike(input);
+          }
+          if (isPromise(input)) {
+              return fromPromise(input);
+          }
+          if (isAsyncIterable(input)) {
+              return fromAsyncIterable(input);
+          }
+          if (isIterable(input)) {
+              return fromIterable(input);
+          }
+          if (isReadableStreamLike(input)) {
+              return fromReadableStreamLike(input);
+          }
+      }
+      throw createInvalidObservableTypeError(input);
+  }
+  function fromInteropObservable(obj) {
+      return new Observable(function (subscriber) {
+          var obs = obj[observable]();
+          if (isFunction(obs.subscribe)) {
+              return obs.subscribe(subscriber);
+          }
+          throw new TypeError('Provided object does not correctly implement Symbol.observable');
+      });
+  }
+  function fromArrayLike(array) {
+      return new Observable(function (subscriber) {
+          for (var i = 0; i < array.length && !subscriber.closed; i++) {
+              subscriber.next(array[i]);
+          }
+          subscriber.complete();
+      });
+  }
+  function fromPromise(promise) {
+      return new Observable(function (subscriber) {
+          promise
+              .then(function (value) {
+              if (!subscriber.closed) {
+                  subscriber.next(value);
+                  subscriber.complete();
+              }
+          }, function (err) { return subscriber.error(err); })
+              .then(null, reportUnhandledError);
+      });
+  }
+  function fromIterable(iterable) {
+      return new Observable(function (subscriber) {
+          var e_1, _a;
+          try {
+              for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
+                  var value = iterable_1_1.value;
+                  subscriber.next(value);
+                  if (subscriber.closed) {
+                      return;
+                  }
+              }
+          }
+          catch (e_1_1) { e_1 = { error: e_1_1 }; }
+          finally {
+              try {
+                  if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1);
+              }
+              finally { if (e_1) throw e_1.error; }
+          }
+          subscriber.complete();
+      });
+  }
+  function fromAsyncIterable(asyncIterable) {
+      return new Observable(function (subscriber) {
+          process$1(asyncIterable, subscriber).catch(function (err) { return subscriber.error(err); });
+      });
+  }
+  function fromReadableStreamLike(readableStream) {
+      return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
+  }
+  function process$1(asyncIterable, subscriber) {
+      var asyncIterable_1, asyncIterable_1_1;
+      var e_2, _a;
+      return __awaiter(this, void 0, void 0, function () {
+          var value, e_2_1;
+          return __generator(this, function (_b) {
+              switch (_b.label) {
+                  case 0:
+                      _b.trys.push([0, 5, 6, 11]);
+                      asyncIterable_1 = __asyncValues(asyncIterable);
+                      _b.label = 1;
+                  case 1: return [4, asyncIterable_1.next()];
+                  case 2:
+                      if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
+                      value = asyncIterable_1_1.value;
+                      subscriber.next(value);
+                      if (subscriber.closed) {
+                          return [2];
+                      }
+                      _b.label = 3;
+                  case 3: return [3, 1];
+                  case 4: return [3, 11];
+                  case 5:
+                      e_2_1 = _b.sent();
+                      e_2 = { error: e_2_1 };
+                      return [3, 11];
+                  case 6:
+                      _b.trys.push([6, , 9, 10]);
+                      if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8];
+                      return [4, _a.call(asyncIterable_1)];
+                  case 7:
+                      _b.sent();
+                      _b.label = 8;
+                  case 8: return [3, 10];
+                  case 9:
+                      if (e_2) throw e_2.error;
+                      return [7];
+                  case 10: return [7];
+                  case 11:
+                      subscriber.complete();
+                      return [2];
+              }
+          });
+      });
+  }
+
+  function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
+      if (delay === void 0) { delay = 0; }
+      if (repeat === void 0) { repeat = false; }
+      var scheduleSubscription = scheduler.schedule(function () {
+          work();
+          if (repeat) {
+              parentSubscription.add(this.schedule(null, delay));
+          }
+          else {
+              this.unsubscribe();
+          }
+      }, delay);
+      parentSubscription.add(scheduleSubscription);
+      if (!repeat) {
+          return scheduleSubscription;
+      }
+  }
+
+  function observeOn(scheduler, delay) {
+      if (delay === void 0) { delay = 0; }
+      return operate(function (source, subscriber) {
+          source.subscribe(createOperatorSubscriber(subscriber, function (value) { return executeSchedule(subscriber, scheduler, function () { return subscriber.next(value); }, delay); }, function () { return executeSchedule(subscriber, scheduler, function () { return subscriber.complete(); }, delay); }, function (err) { return executeSchedule(subscriber, scheduler, function () { return subscriber.error(err); }, delay); }));
+      });
+  }
+
+  function subscribeOn(scheduler, delay) {
+      if (delay === void 0) { delay = 0; }
+      return operate(function (source, subscriber) {
+          subscriber.add(scheduler.schedule(function () { return source.subscribe(subscriber); }, delay));
+      });
+  }
+
+  function scheduleObservable(input, scheduler) {
+      return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+  }
+
+  function schedulePromise(input, scheduler) {
+      return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+  }
+
+  function scheduleArray(input, scheduler) {
+      return new Observable(function (subscriber) {
+          var i = 0;
+          return scheduler.schedule(function () {
+              if (i === input.length) {
+                  subscriber.complete();
+              }
+              else {
+                  subscriber.next(input[i++]);
+                  if (!subscriber.closed) {
+                      this.schedule();
+                  }
+              }
+          });
+      });
+  }
+
+  function scheduleIterable(input, scheduler) {
+      return new Observable(function (subscriber) {
+          var iterator$1;
+          executeSchedule(subscriber, scheduler, function () {
+              iterator$1 = input[iterator]();
+              executeSchedule(subscriber, scheduler, function () {
+                  var _a;
+                  var value;
+                  var done;
+                  try {
+                      (_a = iterator$1.next(), value = _a.value, done = _a.done);
+                  }
+                  catch (err) {
+                      subscriber.error(err);
+                      return;
+                  }
+                  if (done) {
+                      subscriber.complete();
+                  }
+                  else {
+                      subscriber.next(value);
+                  }
+              }, 0, true);
+          });
+          return function () { return isFunction(iterator$1 === null || iterator$1 === void 0 ? void 0 : iterator$1.return) && iterator$1.return(); };
+      });
+  }
+
+  function scheduleAsyncIterable(input, scheduler) {
+      if (!input) {
+          throw new Error('Iterable cannot be null');
+      }
+      return new Observable(function (subscriber) {
+          executeSchedule(subscriber, scheduler, function () {
+              var iterator = input[Symbol.asyncIterator]();
+              executeSchedule(subscriber, scheduler, function () {
+                  iterator.next().then(function (result) {
+                      if (result.done) {
+                          subscriber.complete();
+                      }
+                      else {
+                          subscriber.next(result.value);
+                      }
+                  });
+              }, 0, true);
+          });
+      });
+  }
+
+  function scheduleReadableStreamLike(input, scheduler) {
+      return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
+  }
+
+  function scheduled(input, scheduler) {
+      if (input != null) {
+          if (isInteropObservable(input)) {
+              return scheduleObservable(input, scheduler);
+          }
+          if (isArrayLike(input)) {
+              return scheduleArray(input, scheduler);
+          }
+          if (isPromise(input)) {
+              return schedulePromise(input, scheduler);
+          }
+          if (isAsyncIterable(input)) {
+              return scheduleAsyncIterable(input, scheduler);
+          }
+          if (isIterable(input)) {
+              return scheduleIterable(input, scheduler);
+          }
+          if (isReadableStreamLike(input)) {
+              return scheduleReadableStreamLike(input, scheduler);
+          }
+      }
+      throw createInvalidObservableTypeError(input);
+  }
+
+  function from(input, scheduler) {
+      return scheduler ? scheduled(input, scheduler) : innerFrom(input);
+  }
+
   var EmptyError = createErrorClass(function (_super) { return function EmptyErrorImpl() {
       _super(this);
       this.name = 'EmptyError';
@@ -2108,6 +2519,62 @@
       });
   }
 
+  var isArray$2 = Array.isArray;
+  function callOrApply(fn, args) {
+      return isArray$2(args) ? fn.apply(void 0, __spreadArray([], __read(args))) : fn(args);
+  }
+  function mapOneOrManyArgs(fn) {
+      return map(function (args) { return callOrApply(fn, args); });
+  }
+
+  function combineLatestInit(observables, scheduler, valueTransform) {
+      if (valueTransform === void 0) { valueTransform = identity; }
+      return function (subscriber) {
+          maybeSchedule(scheduler, function () {
+              var length = observables.length;
+              var values = new Array(length);
+              var active = length;
+              var remainingFirstValues = length;
+              var _loop_1 = function (i) {
+                  maybeSchedule(scheduler, function () {
+                      var source = from(observables[i], scheduler);
+                      var hasFirstValue = false;
+                      source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+                          values[i] = value;
+                          if (!hasFirstValue) {
+                              hasFirstValue = true;
+                              remainingFirstValues--;
+                          }
+                          if (!remainingFirstValues) {
+                              subscriber.next(valueTransform(values.slice()));
+                          }
+                      }, function () {
+                          if (!--active) {
+                              subscriber.complete();
+                          }
+                      }));
+                  }, subscriber);
+              };
+              for (var i = 0; i < length; i++) {
+                  _loop_1(i);
+              }
+          }, subscriber);
+      };
+  }
+  function maybeSchedule(scheduler, execute, subscription) {
+      if (scheduler) {
+          executeSchedule(subscription, scheduler, execute);
+      }
+      else {
+          execute();
+      }
+  }
+
+  var isArray$1 = Array.isArray;
+  function argsOrArgArray(args) {
+      return args.length === 1 && isArray$1(args[0]) ? args[0] : args;
+  }
+
   function filter(predicate, thisArg) {
       return operate(function (source, subscriber) {
           var index = 0;
@@ -2115,6 +2582,29 @@
       });
   }
 
+  function combineLatest() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+      }
+      var resultSelector = popResultSelector(args);
+      return resultSelector
+          ? pipe(combineLatest.apply(void 0, __spreadArray([], __read(args))), mapOneOrManyArgs(resultSelector))
+          : operate(function (source, subscriber) {
+              combineLatestInit(__spreadArray([source], __read(argsOrArgArray(args))))(subscriber);
+          });
+  }
+
+  function combineLatestWith() {
+      var otherSources = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+          otherSources[_i] = arguments[_i];
+      }
+      return combineLatest.apply(void 0, __spreadArray([], __read(otherSources)));
+  }
+
+  var s={0:8203,1:8204,2:8205,3:8290,4:8291,5:8288,6:65279,7:8289,8:119155,9:119156,a:119157,b:119158,c:119159,d:119160,e:119161,f:119162},c={0:8203,1:8204,2:8205,3:65279},d=new Array(4).fill(String.fromCodePoint(c[0])).join("");function E(t){let e=JSON.stringify(t);return `${d}${Array.from(e).map(r=>{let n=r.charCodeAt(0);if(n>255)throw new Error(`Only ASCII edit info can be encoded. Error attempting to encode ${e} on character ${r} (${n})`);return Array.from(n.toString(4).padStart(4,"0")).map(o=>String.fromCodePoint(c[o])).join("")}).join("")}`}function I(t){return Number.isNaN(Number(t))?Boolean(Date.parse(t)):!1}function x(t){try{new URL(t,t.startsWith("/")?"https://acme.com":void 0);}catch{return !1}return !0}function b(t,e,r="auto"){return r===!0||r==="auto"&&(I(t)||x(t))?t:`${t}${E(e)}`}Object.fromEntries(Object.entries(c).map(t=>t.reverse()));Object.fromEntries(Object.entries(s).map(t=>t.reverse()));var S=`${Object.values(s).map(t=>`\\u{${t.toString(16)}}`).join("")}`,f=new RegExp(`[${S}]{4,}`,"gu");function X(t){var e;return {cleaned:t.replace(f,""),encoded:((e=t.match(f))==null?void 0:e[0])||""}}
+
   const MAX_ITEMS_IN_ERROR_MESSAGE = 5;
   class ClientError extends Error {
     constructor(res) {
@@ -2763,7 +3253,8 @@
   const defaultConfig = {
     apiHost: "https://api.sanity.io",
     apiVersion: "1",
-    useProjectHostname: true
+    useProjectHostname: true,
+    stega: { enabled: false }
   };
   const LOCALHOSTS = ["localhost", "127.0.0.1", "0.0.0.0"];
   const isLocal = (host) => LOCALHOSTS.indexOf(host) !== -1;
@@ -2790,11 +3281,21 @@
     }
   };
   const initConfig = (config, prevConfig) => {
-    const specifiedConfig = Object.assign({}, prevConfig, config);
+    const specifiedConfig = {
+      ...prevConfig,
+      ...config,
+      stega: {
+        ...typeof prevConfig.stega === "boolean" ? { enabled: prevConfig.stega } : prevConfig.stega || defaultConfig.stega,
+        ...typeof config.stega === "boolean" ? { enabled: config.stega } : config.stega || {}
+      }
+    };
     if (!specifiedConfig.apiVersion) {
       printNoApiVersionSpecifiedWarning();
     }
-    const newConfig = Object.assign({}, defaultConfig, specifiedConfig);
+    const newConfig = {
+      ...defaultConfig,
+      ...specifiedConfig
+    };
     const projectBased = newConfig.useProjectHostname;
     if (typeof Promise === "undefined") {
       const helpUrl = generateHelpUrl("js-client-promise-polyfill");
@@ -2806,14 +3307,25 @@
     if (typeof newConfig.perspective === "string") {
       validateApiPerspective(newConfig.perspective);
     }
-    if ("encodeSourceMapAtPath" in newConfig || "encodeSourceMap" in newConfig || "studioUrl" in newConfig || "logger" in newConfig) {
+    if ("encodeSourceMap" in newConfig) {
+      throw new Error(
+        "It looks like you're using options meant for '@sanity/preview-kit/client'. 'encodeSourceMap' is not supported in '@sanity/client'. Did you mean 'stega.enabled'?"
+      );
+    }
+    if ("encodeSourceMapAtPath" in newConfig) {
       throw new Error(
-        "It looks like you're using options meant for '@sanity/preview-kit/client', such as 'encodeSourceMapAtPath', 'encodeSourceMap', 'studioUrl' and 'logger'. Make sure you're using the right import."
+        "It looks like you're using options meant for '@sanity/preview-kit/client'. 'encodeSourceMapAtPath' is not supported in '@sanity/client'. Did you mean 'stega.filter'?"
       );
     }
-    if ("stega" in newConfig && newConfig["stega"] !== void 0 && newConfig["stega"] !== false) {
+    if (typeof newConfig.stega.enabled !== "boolean") {
+      throw new Error("stega.enabled must be a boolean, received ".concat(newConfig.stega.enabled));
+    }
+    if (newConfig.stega.enabled && newConfig.stega.studioUrl === void 0) {
+      throw new Error("stega.studioUrl must be defined when stega.enabled is true");
+    }
+    if (newConfig.stega.enabled && typeof newConfig.stega.studioUrl !== "string" && typeof newConfig.stega.studioUrl !== "function") {
       throw new Error(
-        "It looks like you're using options meant for '@sanity/client/stega'. Make sure you're using the right import. Or set 'stega' in 'createClient' to 'false'."
+        "stega.studioUrl must be a string or a function, received ".concat(newConfig.stega.studioUrl)
       );
     }
     const isBrowser = typeof window !== "undefined" && window.location && window.location.hostname;
@@ -2874,6 +3386,20 @@
     });
   }
 
+  function vercelStegaCleanAll(result) {
+    try {
+      return JSON.parse(
+        JSON.stringify(result, (key, value) => {
+          if (typeof value !== "string")
+            return value;
+          return X(value).cleaned;
+        })
+      );
+    } catch {
+      return result;
+    }
+  }
+
   const encodeQueryString = ({
     query,
     params = {},
@@ -2915,21 +3441,38 @@
     return indexed;
   }, /* @__PURE__ */ Object.create(null));
   const getQuerySizeLimit = 11264;
-  function _fetch(client, httpRequest, query, params, options = {}) {
-    if ("stega" in options && options["stega"] !== void 0 && options["stega"] !== false) {
-      throw new Error(
-        "It looks like you're using options meant for '@sanity/client/stega'. Make sure you're using the right import. Or set 'stega' in 'fetch' to 'false'."
-      );
-    }
+  function _fetch(client, httpRequest, _stega, query, _params, options = {}) {
+    const stega = "stega" in options ? {
+      ..._stega || {},
+      ...typeof options.stega === "boolean" ? { enabled: options.stega } : options.stega || {}
+    } : _stega;
+    const params = stega.enabled ? vercelStegaCleanAll(_params) : _params;
     const mapResponse = options.filterResponse === false ? (res) => res : (res) => res.result;
     const { cache, next, ...opts } = {
       // Opt out of setting a `signal` on an internal `fetch` if one isn't provided.
       // This is necessary in React Server Components to avoid opting out of Request Memoization.
       useAbortSignal: typeof options.signal !== "undefined",
+      // Set `resultSourceMap' when stega is enabled, as it's required for encoding.
+      resultSourceMap: stega.enabled ? "withKeyArraySelector" : options.resultSourceMap,
       ...options
     };
     const reqOpts = typeof cache !== "undefined" || typeof next !== "undefined" ? { ...opts, fetch: { cache, next } } : opts;
-    return _dataRequest(client, httpRequest, "query", { query, params }, reqOpts).pipe(map(mapResponse));
+    const $request = _dataRequest(client, httpRequest, "query", { query, params }, reqOpts);
+    return stega.enabled ? $request.pipe(
+      combineLatestWith(
+        from(
+          Promise.resolve().then(function () { return stegaEncodeSourceMap9L0STMBo; }).then(function (n) { return n.stegaEncodeSourceMap$1; }).then(
+            ({ stegaEncodeSourceMap }) => stegaEncodeSourceMap
+          )
+        )
+      ),
+      map(
+        ([res, stegaEncodeSourceMap]) => {
+          const result = stegaEncodeSourceMap(res.result, res.resultSourceMap, stega);
+          return mapResponse({ ...res, result });
+        }
+      )
+    ) : $request.pipe(map(mapResponse));
   }
   function _getDocument(client, httpRequest, id, opts = {}) {
     const options = { uri: _getDataUrl(client, "doc", id), json: true, tag: opts.tag };
@@ -3670,10 +4213,25 @@
      * @param newConfig - New client configuration properties, shallowly merged with existing configuration
      */
     withConfig(newConfig) {
-      return new _ObservableSanityClient(__privateGet(this, _httpRequest), { ...this.config(), ...newConfig });
+      const thisConfig = this.config();
+      return new _ObservableSanityClient(__privateGet(this, _httpRequest), {
+        ...this.config(),
+        ...newConfig,
+        stega: {
+          ...thisConfig.stega || {},
+          ...typeof (newConfig == null ? void 0 : newConfig.stega) === "boolean" ? { enabled: newConfig.stega } : (newConfig == null ? void 0 : newConfig.stega) || {}
+        }
+      });
     }
     fetch(query, params, options = {}) {
-      return _fetch(this, __privateGet(this, _httpRequest), query, params, options);
+      return _fetch(
+        this,
+        __privateGet(this, _httpRequest),
+        __privateGet(this, _clientConfig).stega,
+        query,
+        params,
+        options
+      );
     }
     /**
      * Fetch a single document with the given ID.
@@ -3805,10 +4363,27 @@
      * @param newConfig - New client configuration properties, shallowly merged with existing configuration
      */
     withConfig(newConfig) {
-      return new _SanityClient(__privateGet(this, _httpRequest2), { ...this.config(), ...newConfig });
+      const thisConfig = this.config();
+      return new _SanityClient(__privateGet(this, _httpRequest2), {
+        ...thisConfig,
+        ...newConfig,
+        stega: {
+          ...thisConfig.stega || {},
+          ...typeof (newConfig == null ? void 0 : newConfig.stega) === "boolean" ? { enabled: newConfig.stega } : (newConfig == null ? void 0 : newConfig.stega) || {}
+        }
+      });
     }
     fetch(query, params, options = {}) {
-      return lastValueFrom(_fetch(this, __privateGet(this, _httpRequest2), query, params, options));
+      return lastValueFrom(
+        _fetch(
+          this,
+          __privateGet(this, _httpRequest2),
+          __privateGet(this, _clientConfig2).stega,
+          query,
+          params,
+          options
+        )
+      );
     }
     /**
      * Fetch a single document with the given ID.
@@ -3943,6 +4518,484 @@
   const createClient = exp.createClient;
   const deprecatedCreateClient = defineDeprecatedCreateClient(createClient);
 
+  const reKeySegment = /_key\s*==\s*['"](.*)['"]/;
+  function isKeySegment(segment) {
+    if (typeof segment === "string") {
+      return reKeySegment.test(segment.trim());
+    }
+    return typeof segment === "object" && "_key" in segment;
+  }
+  function toString(path) {
+    if (!Array.isArray(path)) {
+      throw new Error("Path is not an array");
+    }
+    return path.reduce((target, segment, i) => {
+      const segmentType = typeof segment;
+      if (segmentType === "number") {
+        return "".concat(target, "[").concat(segment, "]");
+      }
+      if (segmentType === "string") {
+        const separator = i === 0 ? "" : ".";
+        return "".concat(target).concat(separator).concat(segment);
+      }
+      if (isKeySegment(segment) && segment._key) {
+        return "".concat(target, '[_key=="').concat(segment._key, '"]');
+      }
+      if (Array.isArray(segment)) {
+        const [from, to] = segment;
+        return "".concat(target, "[").concat(from, ":").concat(to, "]");
+      }
+      throw new Error("Unsupported path segment `".concat(JSON.stringify(segment), "`"));
+    }, "");
+  }
+
+  const ESCAPE = {
+    "\f": "\\f",
+    "\n": "\\n",
+    "\r": "\\r",
+    "	": "\\t",
+    "'": "\\'",
+    "\\": "\\\\"
+  };
+  const UNESCAPE = {
+    "\\f": "\f",
+    "\\n": "\n",
+    "\\r": "\r",
+    "\\t": "	",
+    "\\'": "'",
+    "\\\\": "\\"
+  };
+  function jsonPath(path) {
+    return "$".concat(path.map((segment) => {
+      if (typeof segment === "string") {
+        const escapedKey = segment.replace(/[\f\n\r\t'\\]/g, (match) => {
+          return ESCAPE[match];
+        });
+        return "['".concat(escapedKey, "']");
+      }
+      if (typeof segment === "number") {
+        return "[".concat(segment, "]");
+      }
+      if (segment._key !== "") {
+        const escapedKey = segment._key.replace(/['\\]/g, (match) => {
+          return ESCAPE[match];
+        });
+        return "[?(@._key=='".concat(escapedKey, "')]");
+      }
+      return "[".concat(segment._index, "]");
+    }).join(""));
+  }
+  function parseJsonPath(path) {
+    const parsed = [];
+    const parseRe = /\['(.*?)'\]|\[(\d+)\]|\[\?\(@\._key=='(.*?)'\)\]/g;
+    let match;
+    while ((match = parseRe.exec(path)) !== null) {
+      if (match[1] !== void 0) {
+        const key = match[1].replace(/\\(\\|f|n|r|t|')/g, (m) => {
+          return UNESCAPE[m];
+        });
+        parsed.push(key);
+        continue;
+      }
+      if (match[2] !== void 0) {
+        parsed.push(parseInt(match[2], 10));
+        continue;
+      }
+      if (match[3] !== void 0) {
+        const _key = match[3].replace(/\\(\\')/g, (m) => {
+          return UNESCAPE[m];
+        });
+        parsed.push({
+          _key,
+          _index: -1
+        });
+        continue;
+      }
+    }
+    return parsed;
+  }
+  function jsonPathToStudioPath(path) {
+    return path.map((segment) => {
+      if (typeof segment === "string") {
+        return segment;
+      }
+      if (typeof segment === "number") {
+        return segment;
+      }
+      if (segment._key !== "") {
+        return { _key: segment._key };
+      }
+      if (segment._index !== -1) {
+        return segment._index;
+      }
+      throw new Error("invalid segment:".concat(JSON.stringify(segment)));
+    });
+  }
+  function jsonPathToMappingPath(path) {
+    return path.map((segment) => {
+      if (typeof segment === "string") {
+        return segment;
+      }
+      if (typeof segment === "number") {
+        return segment;
+      }
+      if (segment._index !== -1) {
+        return segment._index;
+      }
+      throw new Error("invalid segment:".concat(JSON.stringify(segment)));
+    });
+  }
+
+  function resolveMapping(resultPath, csm) {
+    if (!(csm == null ? void 0 : csm.mappings)) {
+      return void 0;
+    }
+    const resultMappingPath = jsonPath(jsonPathToMappingPath(resultPath));
+    if (csm.mappings[resultMappingPath] !== void 0) {
+      return {
+        mapping: csm.mappings[resultMappingPath],
+        matchedPath: resultMappingPath,
+        pathSuffix: ""
+      };
+    }
+    const mappings = Object.entries(csm.mappings).filter(([key]) => resultMappingPath.startsWith(key)).sort(([key1], [key2]) => key2.length - key1.length);
+    if (mappings.length == 0) {
+      return void 0;
+    }
+    const [matchedPath, mapping] = mappings[0];
+    const pathSuffix = resultMappingPath.substring(matchedPath.length);
+    return { mapping, matchedPath, pathSuffix };
+  }
+
+  function isArray(value) {
+    return value !== null && Array.isArray(value);
+  }
+
+  function isRecord(value) {
+    return typeof value === "object" && value !== null;
+  }
+
+  function walkMap(value, mappingFn, path = []) {
+    if (isArray(value)) {
+      return value.map((v, idx) => {
+        if (isRecord(v)) {
+          const _key = v["_key"];
+          if (typeof _key === "string") {
+            return walkMap(v, mappingFn, path.concat({ _key, _index: idx }));
+          }
+        }
+        return walkMap(v, mappingFn, path.concat(idx));
+      });
+    }
+    if (isRecord(value)) {
+      return Object.fromEntries(
+        Object.entries(value).map(([k, v]) => [k, walkMap(v, mappingFn, path.concat(k))])
+      );
+    }
+    return mappingFn(value, path);
+  }
+
+  function encodeIntoResult(result, csm, encoder) {
+    return walkMap(result, (value, path) => {
+      if (typeof value !== "string") {
+        return value;
+      }
+      const resolveMappingResult = resolveMapping(path, csm);
+      if (!resolveMappingResult) {
+        return value;
+      }
+      const { mapping, matchedPath } = resolveMappingResult;
+      if (mapping.type !== "value") {
+        return value;
+      }
+      if (mapping.source.type !== "documentValue") {
+        return value;
+      }
+      const sourceDocument = csm.documents[mapping.source.document];
+      const sourcePath = csm.paths[mapping.source.path];
+      const matchPathSegments = parseJsonPath(matchedPath);
+      const sourcePathSegments = parseJsonPath(sourcePath);
+      const fullSourceSegments = sourcePathSegments.concat(path.slice(matchPathSegments.length));
+      return encoder({
+        sourcePath: fullSourceSegments,
+        sourceDocument,
+        resultPath: path,
+        value
+      });
+    });
+  }
+
+  const DRAFTS_PREFIX = "drafts.";
+  function getPublishedId(id) {
+    if (id.startsWith(DRAFTS_PREFIX)) {
+      return id.slice(DRAFTS_PREFIX.length);
+    }
+    return id;
+  }
+
+  function createEditUrl(options) {
+    const {
+      baseUrl,
+      workspace: _workspace = "default",
+      tool: _tool = "default",
+      id: _id,
+      type,
+      path
+    } = options;
+    if (!baseUrl) {
+      throw new Error("baseUrl is required");
+    }
+    if (!path) {
+      throw new Error("path is required");
+    }
+    if (!_id) {
+      throw new Error("id is required");
+    }
+    if (baseUrl !== "/" && baseUrl.endsWith("/")) {
+      throw new Error("baseUrl must not end with a slash");
+    }
+    const workspace = _workspace === "default" ? void 0 : _workspace;
+    const tool = _tool === "default" ? void 0 : _tool;
+    const id = getPublishedId(_id);
+    const stringifiedPath = Array.isArray(path) ? toString(jsonPathToStudioPath(path)) : path;
+    const searchParams = new URLSearchParams({
+      baseUrl,
+      id,
+      type,
+      path: stringifiedPath
+    });
+    if (workspace) {
+      searchParams.set("workspace", workspace);
+    }
+    if (tool) {
+      searchParams.set("tool", tool);
+    }
+    const segments = [baseUrl === "/" ? "" : baseUrl];
+    if (workspace) {
+      segments.push(workspace);
+    }
+    const routerParams = [
+      "mode=presentation",
+      "id=".concat(id),
+      "type=".concat(type),
+      "path=".concat(encodeURIComponent(stringifiedPath))
+    ];
+    if (tool) {
+      routerParams.push("tool=".concat(tool));
+    }
+    segments.push("intent", "edit", "".concat(routerParams.join(";"), "?").concat(searchParams));
+    return segments.join("/");
+  }
+
+  function resolveStudioBaseRoute(studioUrl) {
+    let baseUrl = typeof studioUrl === "string" ? studioUrl : studioUrl.baseUrl;
+    if (baseUrl !== "/") {
+      baseUrl = baseUrl.replace(/\/$/, "");
+    }
+    if (typeof studioUrl === "string") {
+      return { baseUrl };
+    }
+    return { ...studioUrl, baseUrl };
+  }
+
+  const filterDefault = ({ sourcePath, value }) => {
+    if (isValidDate(value) || isValidURL(value)) {
+      return false;
+    }
+    const endPath = sourcePath.at(-1);
+    if (sourcePath.at(-2) === "slug" && endPath === "current") {
+      return false;
+    }
+    if (typeof endPath === "string" && endPath.startsWith("_")) {
+      return false;
+    }
+    if (typeof endPath === "number" && sourcePath.at(-2) === "marks") {
+      return false;
+    }
+    if (endPath === "href" && typeof sourcePath.at(-2) === "number" && sourcePath.at(-3) === "markDefs") {
+      return false;
+    }
+    if (endPath === "style" || endPath === "listItem") {
+      return false;
+    }
+    if (sourcePath.some(
+      (path) => path === "meta" || path === "metadata" || path === "openGraph" || path === "seo"
+    )) {
+      return false;
+    }
+    if (typeof endPath === "string" && denylist.has(endPath)) {
+      return false;
+    }
+    return true;
+  };
+  const denylist = /* @__PURE__ */ new Set([
+    "color",
+    "colour",
+    "currency",
+    "email",
+    "format",
+    "gid",
+    "hex",
+    "href",
+    "hsl",
+    "hsla",
+    "icon",
+    "id",
+    "index",
+    "key",
+    "language",
+    "layout",
+    "link",
+    "linkAction",
+    "locale",
+    "lqip",
+    "page",
+    "path",
+    "ref",
+    "rgb",
+    "rgba",
+    "route",
+    "secret",
+    "slug",
+    "status",
+    "tag",
+    "template",
+    "theme",
+    "type",
+    "unit",
+    "url",
+    "username",
+    "variant",
+    "website"
+  ]);
+  function isValidDate(dateString) {
+    return Number.isNaN(Number(dateString)) ? Boolean(Date.parse(dateString)) : false;
+  }
+  function isValidURL(url) {
+    try {
+      new URL(url, url.startsWith("/") ? "https://acme.com" : void 0);
+    } catch {
+      return false;
+    }
+    return true;
+  }
+
+  const TRUNCATE_LENGTH = 20;
+  function stegaEncodeSourceMap(result, resultSourceMap, config) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const { filter, logger, enabled } = config;
+    if (!enabled) {
+      const msg = "config.enabled must be true, don't call this function otherwise";
+      (_a = logger == null ? void 0 : logger.error) == null ? void 0 : _a.call(logger, "[@sanity/client/stega]: ".concat(msg), { result, resultSourceMap, config });
+      throw new TypeError(msg);
+    }
+    if (!resultSourceMap) {
+      (_b = logger == null ? void 0 : logger.error) == null ? void 0 : _b.call(logger, "[@sanity/client/stega]: Missing Content Source Map from response body", {
+        result,
+        resultSourceMap,
+        config
+      });
+      return result;
+    }
+    if (!config.studioUrl) {
+      const msg = "config.studioUrl must be defined";
+      (_c = logger == null ? void 0 : logger.error) == null ? void 0 : _c.call(logger, "[@sanity/client/stega]: ".concat(msg), { result, resultSourceMap, config });
+      throw new TypeError(msg);
+    }
+    const report = {
+      encoded: [],
+      skipped: []
+    };
+    const resultWithStega = encodeIntoResult(
+      result,
+      resultSourceMap,
+      ({ sourcePath, sourceDocument, resultPath, value }) => {
+        if ((typeof filter === "function" ? filter({ sourcePath, resultPath, filterDefault, sourceDocument, value }) : filterDefault({ sourcePath, resultPath, filterDefault, sourceDocument, value })) === false) {
+          if (logger) {
+            report.skipped.push({
+              path: prettyPathForLogging(sourcePath),
+              value: "".concat(value.slice(0, TRUNCATE_LENGTH)).concat(value.length > TRUNCATE_LENGTH ? "..." : ""),
+              length: value.length
+            });
+          }
+          return value;
+        }
+        if (logger) {
+          report.encoded.push({
+            path: prettyPathForLogging(sourcePath),
+            value: "".concat(value.slice(0, TRUNCATE_LENGTH)).concat(value.length > TRUNCATE_LENGTH ? "..." : ""),
+            length: value.length
+          });
+        }
+        const { baseUrl, workspace, tool } = resolveStudioBaseRoute(
+          typeof config.studioUrl === "function" ? config.studioUrl(sourceDocument) : config.studioUrl
+        );
+        if (!baseUrl)
+          return value;
+        const { _id: id, _type: type } = sourceDocument;
+        return b(
+          value,
+          {
+            origin: "sanity.io",
+            href: createEditUrl({
+              baseUrl,
+              workspace,
+              tool,
+              id,
+              type,
+              path: sourcePath
+            })
+          },
+          // We use custom logic to determine if we should skip encoding
+          false
+        );
+      }
+    );
+    if (logger) {
+      const isSkipping = report.skipped.length;
+      const isEncoding = report.encoded.length;
+      if (isSkipping || isEncoding) {
+        (_d = (logger == null ? void 0 : logger.groupCollapsed) || logger.log) == null ? void 0 : _d(
+          "[@sanity/client/stega]: Encoding source map into result"
+        );
+        (_e = logger.log) == null ? void 0 : _e.call(
+          logger,
+          "[@sanity/client/stega]: Paths encoded: ".concat(report.encoded.length, ", skipped: ").concat(report.skipped.length)
+        );
+      }
+      if (report.encoded.length > 0) {
+        (_f = logger == null ? void 0 : logger.log) == null ? void 0 : _f.call(logger, "[@sanity/client/stega]: Table of encoded paths");
+        (_g = (logger == null ? void 0 : logger.table) || logger.log) == null ? void 0 : _g(report.encoded);
+      }
+      if (report.skipped.length > 0) {
+        const skipped = /* @__PURE__ */ new Set();
+        for (const { path } of report.skipped) {
+          skipped.add(path.replace(reKeySegment, "0").replace(/\[\d+\]/g, "[]"));
+        }
+        (_h = logger == null ? void 0 : logger.log) == null ? void 0 : _h.call(logger, "[@sanity/client/stega]: List of skipped paths", [...skipped.values()]);
+      }
+      if (isSkipping || isEncoding) {
+        (_i = logger == null ? void 0 : logger.groupEnd) == null ? void 0 : _i.call(logger);
+      }
+    }
+    return resultWithStega;
+  }
+  function prettyPathForLogging(path) {
+    return toString(jsonPathToStudioPath(path));
+  }
+
+  var stegaEncodeSourceMap$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    stegaEncodeSourceMap: stegaEncodeSourceMap
+  });
+
+  var stegaEncodeSourceMap9L0STMBo = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    encodeIntoResult: encodeIntoResult,
+    stegaEncodeSourceMap: stegaEncodeSourceMap,
+    stegaEncodeSourceMap$1: stegaEncodeSourceMap$1
+  });
+
   var eventsource = {exports: {}};
 
   /** @license