@vitessce/vit-s 3.3.2 → 3.3.3

package/dist/index.js

@@ -1298,7 +1298,7 @@ function _typeof$8(obj) {
     return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
   }, _typeof$8(obj);
 }
-function isPlainObject$2(item) {
+function isPlainObject$1(item) {
   return item && _typeof$8(item) === "object" && item.constructor === Object;
 }
 function deepmerge(target, source) {
@@ -1306,12 +1306,12 @@ function deepmerge(target, source) {
     clone: true
   };
   var output = options.clone ? _extends$6({}, target) : target;
-  if (isPlainObject$2(target) && isPlainObject$2(source)) {
+  if (isPlainObject$1(target) && isPlainObject$1(source)) {
     Object.keys(source).forEach(function(key) {
       if (key === "__proto__") {
         return;
       }
-      if (isPlainObject$2(source[key]) && key in target) {
+      if (isPlainObject$1(source[key]) && key in target) {
         output[key] = deepmerge(target[key], source[key], options);
       } else {
         output[key] = source[key];
@@ -1488,7 +1488,7 @@ object-assign
 @license MIT
 */
 var getOwnPropertySymbols$1 = Object.getOwnPropertySymbols;
-var hasOwnProperty$m = Object.prototype.hasOwnProperty;
+var hasOwnProperty$l = Object.prototype.hasOwnProperty;
 var propIsEnumerable = Object.prototype.propertyIsEnumerable;
 function toObject(val) {
   if (val === null || val === void 0) {
@@ -1535,7 +1535,7 @@ var objectAssign = shouldUseNative() ? Object.assign : function(target, source)
   for (var s = 1; s < arguments.length; s++) {
     from = Object(arguments[s]);
     for (var key in from) {
-      if (hasOwnProperty$m.call(from, key)) {
+      if (hasOwnProperty$l.call(from, key)) {
         to[key] = from[key];
       }
     }
@@ -2952,7 +2952,7 @@ function _typeof$7(obj) {
     return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
   }, _typeof$7(obj);
 }
-function merge$2(acc, item) {
+function merge(acc, item) {
   if (!item) {
     return acc;
   }
@@ -3047,7 +3047,7 @@ function compose() {
     return styles20.reduce(function(acc, style) {
       var output = style(props);
       if (output) {
-        return merge$2(acc, output);
+        return merge(acc, output);
       }
       return acc;
     }, {});
@@ -3115,12 +3115,12 @@ function styleFunctionSx(styleFunction2) {
   var newStyleFunction = function newStyleFunction2(props) {
     var output = styleFunction2(props);
     if (props.css) {
-      return _extends$5({}, merge$2(output, styleFunction2(_extends$5({
+      return _extends$5({}, merge(output, styleFunction2(_extends$5({
         theme: props.theme
       }, props.css))), omit$1(props.css, [styleFunction2.filterProps]));
     }
     if (props.sx) {
-      return _extends$5({}, merge$2(output, styleFunction2(_extends$5({
+      return _extends$5({}, merge(output, styleFunction2(_extends$5({
         theme: props.theme
       }, props.sx))), omit$1(props.sx, [styleFunction2.filterProps]));
     }
@@ -3469,7 +3469,7 @@ function spacing(props) {
     var styleFromPropValue = getStyleFromPropValue(cssProperties, transformer);
     var propValue = props[prop];
     return handleBreakpoints(props, propValue, styleFromPropValue);
-  }).reduce(merge$2, {});
+  }).reduce(merge, {});
 }
 spacing.propTypes = spacingKeys.reduce(function(obj, key) {
   obj[key] = responsivePropType$1;
@@ -16695,7 +16695,7 @@ function hashQueryKeyByOptions(queryKey, options) {
   return hashFn(queryKey);
 }
 function hashQueryKey(queryKey) {
-  return JSON.stringify(queryKey, (_, val) => isPlainObject$1(val) ? Object.keys(val).sort().reduce((result, key) => {
+  return JSON.stringify(queryKey, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
     result[key] = val[key];
     return result;
   }, {}) : val);
@@ -16720,7 +16720,7 @@ function replaceEqualDeep(a, b) {
     return a;
   }
   const array = isPlainArray(a) && isPlainArray(b);
-  if (array || isPlainObject$1(a) && isPlainObject$1(b)) {
+  if (array || isPlainObject(a) && isPlainObject(b)) {
     const aSize = array ? a.length : Object.keys(a).length;
     const bItems = array ? b : Object.keys(b);
     const bSize = bItems.length;
@@ -16751,7 +16751,7 @@ function shallowEqualObjects(a, b) {
 function isPlainArray(value) {
   return Array.isArray(value) && value.length === Object.keys(value).length;
 }
-function isPlainObject$1(o) {
+function isPlainObject(o) {
   if (!hasObjectPrototype(o)) {
     return false;
   }
@@ -19198,12 +19198,12 @@ var root$9 = freeGlobal$3 || freeSelf$1 || Function("return this")();
 const root$a = root$9;
 var Symbol$5 = root$a.Symbol;
 const Symbol$6 = Symbol$5;
-var objectProto$r = Object.prototype;
-var hasOwnProperty$l = objectProto$r.hasOwnProperty;
-var nativeObjectToString$3 = objectProto$r.toString;
+var objectProto$q = Object.prototype;
+var hasOwnProperty$k = objectProto$q.hasOwnProperty;
+var nativeObjectToString$3 = objectProto$q.toString;
 var symToStringTag$3 = Symbol$6 ? Symbol$6.toStringTag : void 0;
 function getRawTag$2(value) {
-  var isOwn = hasOwnProperty$l.call(value, symToStringTag$3), tag = value[symToStringTag$3];
+  var isOwn = hasOwnProperty$k.call(value, symToStringTag$3), tag = value[symToStringTag$3];
   try {
     value[symToStringTag$3] = void 0;
     var unmasked = true;
@@ -19219,8 +19219,8 @@ function getRawTag$2(value) {
   }
   return result;
 }
-var objectProto$q = Object.prototype;
-var nativeObjectToString$2 = objectProto$q.toString;
+var objectProto$p = Object.prototype;
+var nativeObjectToString$2 = objectProto$p.toString;
 function objectToString$2(value) {
   return nativeObjectToString$2.call(value);
 }
@@ -19333,12 +19333,12 @@ var maskSrcKey$1 = function() {
 function isMasked$2(func) {
   return !!maskSrcKey$1 && maskSrcKey$1 in func;
 }
-var funcProto$4 = Function.prototype;
-var funcToString$4 = funcProto$4.toString;
+var funcProto$3 = Function.prototype;
+var funcToString$3 = funcProto$3.toString;
 function toSource$3(func) {
   if (func != null) {
     try {
-      return funcToString$4.call(func);
+      return funcToString$3.call(func);
     } catch (e) {
     }
     try {
@@ -19350,11 +19350,11 @@ function toSource$3(func) {
 }
 var reRegExpChar$1 = /[\\^$.*+?()[\]{}|]/g;
 var reIsHostCtor$1 = /^\[object .+?Constructor\]$/;
-var funcProto$3 = Function.prototype, objectProto$p = Object.prototype;
-var funcToString$3 = funcProto$3.toString;
-var hasOwnProperty$k = objectProto$p.hasOwnProperty;
+var funcProto$2 = Function.prototype, objectProto$o = Object.prototype;
+var funcToString$2 = funcProto$2.toString;
+var hasOwnProperty$j = objectProto$o.hasOwnProperty;
 var reIsNative$1 = RegExp(
-  "^" + funcToString$3.call(hasOwnProperty$k).replace(reRegExpChar$1, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+  "^" + funcToString$2.call(hasOwnProperty$j).replace(reRegExpChar$1, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
 );
 function baseIsNative$2(value) {
   if (!isObject$3(value) || isMasked$2(value)) {
@@ -19484,11 +19484,11 @@ function baseAssignValue(object, key, value) {
 function eq$7(value, other) {
   return value === other || value !== value && other !== other;
 }
-var objectProto$o = Object.prototype;
-var hasOwnProperty$j = objectProto$o.hasOwnProperty;
+var objectProto$n = Object.prototype;
+var hasOwnProperty$i = objectProto$n.hasOwnProperty;
 function assignValue(object, key, value) {
   var objValue = object[key];
-  if (!(hasOwnProperty$j.call(object, key) && eq$7(objValue, value)) || value === void 0 && !(key in object)) {
+  if (!(hasOwnProperty$i.call(object, key) && eq$7(objValue, value)) || value === void 0 && !(key in object)) {
     baseAssignValue(object, key, value);
   }
 }
@@ -19527,9 +19527,6 @@ function overRest(func, start, transform3) {
     return apply(func, this, otherArgs);
   };
 }
-function baseRest(func, start) {
-  return setToString$1(overRest(func, start, identity), func + "");
-}
 var MAX_SAFE_INTEGER$4 = 9007199254740991;
 function isLength$3(value) {
   return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER$4;
@@ -19547,27 +19544,9 @@ function isIterateeCall(value, index, object) {
   }
   return false;
 }
-function createAssigner(assigner) {
-  return baseRest(function(object, sources) {
-    var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
-    customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
-    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
-      customizer = length < 3 ? void 0 : customizer;
-      length = 1;
-    }
-    object = Object(object);
-    while (++index < length) {
-      var source = sources[index];
-      if (source) {
-        assigner(object, source, index, customizer);
-      }
-    }
-    return object;
-  });
-}
-var objectProto$n = Object.prototype;
+var objectProto$m = Object.prototype;
 function isPrototype$2(value) {
-  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$n;
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$m;
   return value === proto;
 }
 function baseTimes$2(n, iteratee) {
@@ -19581,13 +19560,13 @@ var argsTag$6 = "[object Arguments]";
 function baseIsArguments$2(value) {
   return isObjectLike$5(value) && baseGetTag$5(value) == argsTag$6;
 }
-var objectProto$m = Object.prototype;
-var hasOwnProperty$i = objectProto$m.hasOwnProperty;
-var propertyIsEnumerable$3 = objectProto$m.propertyIsEnumerable;
+var objectProto$l = Object.prototype;
+var hasOwnProperty$h = objectProto$l.hasOwnProperty;
+var propertyIsEnumerable$3 = objectProto$l.propertyIsEnumerable;
 var isArguments$2 = baseIsArguments$2(function() {
   return arguments;
 }()) ? baseIsArguments$2 : function(value) {
-  return isObjectLike$5(value) && hasOwnProperty$i.call(value, "callee") && !propertyIsEnumerable$3.call(value, "callee");
+  return isObjectLike$5(value) && hasOwnProperty$h.call(value, "callee") && !propertyIsEnumerable$3.call(value, "callee");
 };
 const isArguments$3 = isArguments$2;
 function stubFalse$1() {
@@ -19600,11 +19579,11 @@ var Buffer$1 = moduleExports$2 ? root$a.Buffer : void 0;
 var nativeIsBuffer = Buffer$1 ? Buffer$1.isBuffer : void 0;
 var isBuffer$3 = nativeIsBuffer || stubFalse$1;
 const isBuffer$4 = isBuffer$3;
-var argsTag$5 = "[object Arguments]", arrayTag$4 = "[object Array]", boolTag$5 = "[object Boolean]", dateTag$5 = "[object Date]", errorTag$4 = "[object Error]", funcTag$3 = "[object Function]", mapTag$8 = "[object Map]", numberTag$5 = "[object Number]", objectTag$7 = "[object Object]", regexpTag$5 = "[object RegExp]", setTag$8 = "[object Set]", stringTag$5 = "[object String]", weakMapTag$4 = "[object WeakMap]";
+var argsTag$5 = "[object Arguments]", arrayTag$4 = "[object Array]", boolTag$5 = "[object Boolean]", dateTag$5 = "[object Date]", errorTag$4 = "[object Error]", funcTag$3 = "[object Function]", mapTag$8 = "[object Map]", numberTag$5 = "[object Number]", objectTag$6 = "[object Object]", regexpTag$5 = "[object RegExp]", setTag$8 = "[object Set]", stringTag$5 = "[object String]", weakMapTag$4 = "[object WeakMap]";
 var arrayBufferTag$5 = "[object ArrayBuffer]", dataViewTag$7 = "[object DataView]", float32Tag$3 = "[object Float32Array]", float64Tag$3 = "[object Float64Array]", int8Tag$3 = "[object Int8Array]", int16Tag$3 = "[object Int16Array]", int32Tag$3 = "[object Int32Array]", uint8Tag$3 = "[object Uint8Array]", uint8ClampedTag$3 = "[object Uint8ClampedArray]", uint16Tag$3 = "[object Uint16Array]", uint32Tag$3 = "[object Uint32Array]";
 var typedArrayTags$1 = {};
 typedArrayTags$1[float32Tag$3] = typedArrayTags$1[float64Tag$3] = typedArrayTags$1[int8Tag$3] = typedArrayTags$1[int16Tag$3] = typedArrayTags$1[int32Tag$3] = typedArrayTags$1[uint8Tag$3] = typedArrayTags$1[uint8ClampedTag$3] = typedArrayTags$1[uint16Tag$3] = typedArrayTags$1[uint32Tag$3] = true;
-typedArrayTags$1[argsTag$5] = typedArrayTags$1[arrayTag$4] = typedArrayTags$1[arrayBufferTag$5] = typedArrayTags$1[boolTag$5] = typedArrayTags$1[dataViewTag$7] = typedArrayTags$1[dateTag$5] = typedArrayTags$1[errorTag$4] = typedArrayTags$1[funcTag$3] = typedArrayTags$1[mapTag$8] = typedArrayTags$1[numberTag$5] = typedArrayTags$1[objectTag$7] = typedArrayTags$1[regexpTag$5] = typedArrayTags$1[setTag$8] = typedArrayTags$1[stringTag$5] = typedArrayTags$1[weakMapTag$4] = false;
+typedArrayTags$1[argsTag$5] = typedArrayTags$1[arrayTag$4] = typedArrayTags$1[arrayBufferTag$5] = typedArrayTags$1[boolTag$5] = typedArrayTags$1[dataViewTag$7] = typedArrayTags$1[dateTag$5] = typedArrayTags$1[errorTag$4] = typedArrayTags$1[funcTag$3] = typedArrayTags$1[mapTag$8] = typedArrayTags$1[numberTag$5] = typedArrayTags$1[objectTag$6] = typedArrayTags$1[regexpTag$5] = typedArrayTags$1[setTag$8] = typedArrayTags$1[stringTag$5] = typedArrayTags$1[weakMapTag$4] = false;
 function baseIsTypedArray$2(value) {
   return isObjectLike$5(value) && isLength$3(value.length) && !!typedArrayTags$1[baseGetTag$5(value)];
 }
@@ -19631,12 +19610,12 @@ const nodeUtil$2 = nodeUtil$1;
 var nodeIsTypedArray$1 = nodeUtil$2 && nodeUtil$2.isTypedArray;
 var isTypedArray$3 = nodeIsTypedArray$1 ? baseUnary$2(nodeIsTypedArray$1) : baseIsTypedArray$2;
 const isTypedArray$4 = isTypedArray$3;
-var objectProto$l = Object.prototype;
-var hasOwnProperty$h = objectProto$l.hasOwnProperty;
+var objectProto$k = Object.prototype;
+var hasOwnProperty$g = objectProto$k.hasOwnProperty;
 function arrayLikeKeys$2(value, inherited) {
   var isArr = isArray$5(value), isArg = !isArr && isArguments$3(value), isBuff = !isArr && !isArg && isBuffer$4(value), isType = !isArr && !isArg && !isBuff && isTypedArray$4(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes$2(value.length, String) : [], length = result.length;
   for (var key in value) {
-    if ((inherited || hasOwnProperty$h.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+    if ((inherited || hasOwnProperty$g.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
     (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
     isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
     isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
@@ -19653,15 +19632,15 @@ function overArg$2(func, transform3) {
 }
 var nativeKeys$2 = overArg$2(Object.keys, Object);
 const nativeKeys$3 = nativeKeys$2;
-var objectProto$k = Object.prototype;
-var hasOwnProperty$g = objectProto$k.hasOwnProperty;
+var objectProto$j = Object.prototype;
+var hasOwnProperty$f = objectProto$j.hasOwnProperty;
 function baseKeys$2(object) {
   if (!isPrototype$2(object)) {
     return nativeKeys$3(object);
   }
   var result = [];
   for (var key in Object(object)) {
-    if (hasOwnProperty$g.call(object, key) && key != "constructor") {
+    if (hasOwnProperty$f.call(object, key) && key != "constructor") {
       result.push(key);
     }
   }
@@ -19679,15 +19658,15 @@ function nativeKeysIn(object) {
   }
   return result;
 }
-var objectProto$j = Object.prototype;
-var hasOwnProperty$f = objectProto$j.hasOwnProperty;
+var objectProto$i = Object.prototype;
+var hasOwnProperty$e = objectProto$i.hasOwnProperty;
 function baseKeysIn(object) {
   if (!isObject$3(object)) {
     return nativeKeysIn(object);
   }
   var isProto = isPrototype$2(object), result = [];
   for (var key in object) {
-    if (!(key == "constructor" && (isProto || !hasOwnProperty$f.call(object, key)))) {
+    if (!(key == "constructor" && (isProto || !hasOwnProperty$e.call(object, key)))) {
       result.push(key);
     }
   }
@@ -19719,21 +19698,21 @@ function hashDelete$2(key) {
   return result;
 }
 var HASH_UNDEFINED$5 = "__lodash_hash_undefined__";
-var objectProto$i = Object.prototype;
-var hasOwnProperty$e = objectProto$i.hasOwnProperty;
+var objectProto$h = Object.prototype;
+var hasOwnProperty$d = objectProto$h.hasOwnProperty;
 function hashGet$2(key) {
   var data = this.__data__;
   if (nativeCreate$6) {
     var result = data[key];
     return result === HASH_UNDEFINED$5 ? void 0 : result;
   }
-  return hasOwnProperty$e.call(data, key) ? data[key] : void 0;
+  return hasOwnProperty$d.call(data, key) ? data[key] : void 0;
 }
-var objectProto$h = Object.prototype;
-var hasOwnProperty$d = objectProto$h.hasOwnProperty;
+var objectProto$g = Object.prototype;
+var hasOwnProperty$c = objectProto$g.hasOwnProperty;
 function hashHas$2(key) {
   var data = this.__data__;
-  return nativeCreate$6 ? data[key] !== void 0 : hasOwnProperty$d.call(data, key);
+  return nativeCreate$6 ? data[key] !== void 0 : hasOwnProperty$c.call(data, key);
 }
 var HASH_UNDEFINED$4 = "__lodash_hash_undefined__";
 function hashSet$2(key, value) {
@@ -19971,22 +19950,6 @@ function flatRest(func) {
 }
 var getPrototype = overArg$2(Object.getPrototypeOf, Object);
 const getPrototype$1 = getPrototype;
-var objectTag$6 = "[object Object]";
-var funcProto$2 = Function.prototype, objectProto$g = Object.prototype;
-var funcToString$2 = funcProto$2.toString;
-var hasOwnProperty$c = objectProto$g.hasOwnProperty;
-var objectCtorString = funcToString$2.call(Object);
-function isPlainObject(value) {
-  if (!isObjectLike$5(value) || baseGetTag$5(value) != objectTag$6) {
-    return false;
-  }
-  var proto = getPrototype$1(value);
-  if (proto === null) {
-    return true;
-  }
-  var Ctor = hasOwnProperty$c.call(proto, "constructor") && proto.constructor;
-  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString$2.call(Ctor) == objectCtorString;
-}
 function stackClear$2() {
   this.__data__ = new ListCache$5();
   this.size = 0;
@@ -20751,86 +20714,6 @@ function debounce(func, wait, options) {
   debounced.flush = flush;
   return debounced;
 }
-function assignMergeValue(object, key, value) {
-  if (value !== void 0 && !eq$7(object[key], value) || value === void 0 && !(key in object)) {
-    baseAssignValue(object, key, value);
-  }
-}
-function isArrayLikeObject(value) {
-  return isObjectLike$5(value) && isArrayLike$2(value);
-}
-function safeGet(object, key) {
-  if (key === "constructor" && typeof object[key] === "function") {
-    return;
-  }
-  if (key == "__proto__") {
-    return;
-  }
-  return object[key];
-}
-function toPlainObject(value) {
-  return copyObject(value, keysIn(value));
-}
-function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
-  var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
-  if (stacked) {
-    assignMergeValue(object, key, stacked);
-    return;
-  }
-  var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : void 0;
-  var isCommon = newValue === void 0;
-  if (isCommon) {
-    var isArr = isArray$5(srcValue), isBuff = !isArr && isBuffer$4(srcValue), isTyped = !isArr && !isBuff && isTypedArray$4(srcValue);
-    newValue = srcValue;
-    if (isArr || isBuff || isTyped) {
-      if (isArray$5(objValue)) {
-        newValue = objValue;
-      } else if (isArrayLikeObject(objValue)) {
-        newValue = copyArray(objValue);
-      } else if (isBuff) {
-        isCommon = false;
-        newValue = cloneBuffer(srcValue, true);
-      } else if (isTyped) {
-        isCommon = false;
-        newValue = cloneTypedArray(srcValue, true);
-      } else {
-        newValue = [];
-      }
-    } else if (isPlainObject(srcValue) || isArguments$3(srcValue)) {
-      newValue = objValue;
-      if (isArguments$3(objValue)) {
-        newValue = toPlainObject(objValue);
-      } else if (!isObject$3(objValue) || isFunction$4(objValue)) {
-        newValue = initCloneObject(srcValue);
-      }
-    } else {
-      isCommon = false;
-    }
-  }
-  if (isCommon) {
-    stack.set(srcValue, newValue);
-    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
-    stack["delete"](srcValue);
-  }
-  assignMergeValue(object, key, newValue);
-}
-function baseMerge(object, source, srcIndex, customizer, stack) {
-  if (object === source) {
-    return;
-  }
-  baseFor$1(source, function(srcValue, key) {
-    stack || (stack = new Stack$2());
-    if (isObject$3(srcValue)) {
-      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
-    } else {
-      var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : void 0;
-      if (newValue === void 0) {
-        newValue = srcValue;
-      }
-      assignMergeValue(object, key, newValue);
-    }
-  }, keysIn);
-}
 function arrayEvery(array, predicate) {
   var index = -1, length = array == null ? 0 : array.length;
   while (++index < length) {
@@ -20861,10 +20744,6 @@ function isEqual$1(value, other) {
 function isMatch(object, source) {
   return object === source || baseIsMatch(object, source, getMatchData(source));
 }
-var merge = createAssigner(function(object, source, srcIndex) {
-  baseMerge(object, source, srcIndex);
-});
-const merge$1 = merge;
 function baseSet(object, path, value, customizer) {
   if (!isObject$3(object)) {
     return object;
@@ -25006,6 +24885,20 @@ function getNextScope(prevScopes) {
   } while (prevScopes.includes(nextScope));
   return nextScope;
 }
+function createPrefixedGetNextScopeNumeric(prefix2) {
+  return (prevScopes) => {
+    let nextScopeInt = 0;
+    let nextScopeStr;
+    do {
+      nextScopeStr = `${prefix2}${nextScopeInt}`;
+      nextScopeInt += 1;
+    } while (prevScopes.includes(nextScopeStr));
+    return nextScopeStr;
+  };
+}
+function getInitialCoordinationScopePrefix(datasetUid, dataType) {
+  return `init_${datasetUid}_${dataType}_`;
+}
 let getRandomValues;
 const rnds8 = new Uint8Array(16);
 function rng() {
@@ -35161,7 +35054,9 @@ const FileType$1 = {
   OBS_SEGMENTATIONS_JSON: "obsSegmentations.json",
   OBS_SETS_CSV: "obsSets.csv",
   OBS_SETS_JSON: "obsSets.json",
+  // OME-Zarr
   IMAGE_OME_ZARR: "image.ome-zarr",
+  OBS_SEGMENTATIONS_OME_ZARR: "obsSegmentations.ome-zarr",
   // AnnData
   OBS_FEATURE_MATRIX_ANNDATA_ZARR: "obsFeatureMatrix.anndata.zarr",
   OBS_SETS_ANNDATA_ZARR: "obsSets.anndata.zarr",
@@ -35344,6 +35239,7 @@ const STATUS = {
 };
 const DATA_TYPE_COORDINATION_VALUE_USAGE = {
   [DataType$1.OBS_SEGMENTATIONS]: [
+    CoordinationType$1.FILE_UID,
     CoordinationType$1.OBS_TYPE
   ],
   [DataType$1.OBS_EMBEDDING]: [
@@ -35375,7 +35271,9 @@ const DATA_TYPE_COORDINATION_VALUE_USAGE = {
     CoordinationType$1.FEATURE_VALUE_TYPE
   ],
   [DataType$1.GENOMIC_PROFILES]: [],
-  [DataType$1.IMAGE]: [],
+  [DataType$1.IMAGE]: [
+    CoordinationType$1.FILE_UID
+  ],
   [DataType$1.NEIGHBORHOODS]: []
 };
 const AUTO_INDEPENDENT_COORDINATION_TYPES = [
@@ -35394,10 +35292,10 @@ const AUTO_INDEPENDENT_COORDINATION_TYPES = [
   CoordinationType$1.EMBEDDING_OBS_OPACITY
 ];
 const note = "This file is autogenerated by .changeset/post-changelog.mjs.";
-const version = "3.3.2";
-const date = "2023-11-30";
+const version = "3.3.3";
+const date = "2024-01-25";
 const branch = "changeset-release/main";
-const hash = "a562d787";
+const hash = "c2264756";
 const META_VERSION = {
   note,
   version,
@@ -35753,30 +35651,39 @@ const omeCoordinateTransformations = z.array(z.union([
     scale: z.array(z.number())
   })
 ]));
-z.object({
+const imageOmeTiffSchema = z.object({
   offsetsUrl: z.string().optional(),
   coordinateTransformations: omeCoordinateTransformations.optional()
 });
+imageOmeTiffSchema.extend({
+  obsTypesFromChannelNames: z.boolean().optional()
+});
 const imageOmeZarrSchema = z.object({
   coordinateTransformations: omeCoordinateTransformations.optional()
 });
 imageOmeZarrSchema.extend({
+  obsTypesFromChannelNames: z.boolean().optional()
+});
+const imageSpatialdataSchema = imageOmeZarrSchema.extend({
   path: z.string()
 });
-z.object({
+const obsSegmentationsSpatialdataSchema = z.object({
+  // TODO: should this also extend the imageOmeZarrSchema?
+  // TODO: should this be renamed labelsSpatialdataSchema?
+  // TODO: support obsTypesFromChannelNames?
   path: z.string()
 });
 z.object({
   path: z.string()
 });
-z.object({
+const obsSpotsSpatialdataSchema = z.object({
   path: z.string(),
   tablePath: z.string().optional().describe("The path to a table which annotates the spots. If available but not specified, the spot identifiers may not be aligned with associated tabular data as expected.")
 });
-annDataObsFeatureMatrix.extend({
+const obsFeatureMatrixSpatialdataSchema = annDataObsFeatureMatrix.extend({
   region: z.string().describe("The name of a region to use to filter instances (i.e., rows) in the table").optional()
 });
-z.object({
+const obsSetsSpatialdataSchema = z.object({
   region: z.string().describe("The name of a region to use to filter instances (i.e., rows) in the table").optional(),
   tablePath: z.string().optional().describe("The path to a table which contains the index for the set values."),
   obsSets: annDataObsSets
@@ -35839,6 +35746,19 @@ z.object({
     z.array(annDataConvenienceObsEmbeddingItem)
   ])
 }).partial();
+z.object({
+  // TODO: should `image` be a special schema
+  // to allow specifying fileUid (like for embeddingType)?
+  image: imageSpatialdataSchema,
+  // TODO: should this be a special schema
+  // to allow specifying fileUid (like for embeddingType)?
+  labels: obsSegmentationsSpatialdataSchema,
+  obsFeatureMatrix: obsFeatureMatrixSpatialdataSchema,
+  obsSpots: obsSpotsSpatialdataSchema,
+  // TODO: obsPoints
+  // TODO: obsLocations
+  obsSets: obsSetsSpatialdataSchema
+}).partial();
 z.object({
   obsLabelsTypes: z.array(z.string()).optional(),
   embeddingTypes: z.array(z.string()).optional()
@@ -36185,6 +36105,712 @@ function shallow(objA, objB) {
   }
   return true;
 }
+class VitessceConfigDatasetFile {
+  /**
+   * Construct a new file definition instance.
+   * @param {string} url The URL to the file.
+   * @param {string} dataType The type of data contained in the file.
+   * @param {string} fileType The file type.
+   * @param {object|array|null} options An optional object or array
+   * which may provide additional parameters to the loader class
+   * corresponding to the specified fileType.
+   */
+  constructor(url, fileType, coordinationValues, options) {
+    this.file = {
+      url,
+      fileType,
+      ...coordinationValues ? { coordinationValues } : {},
+      ...options ? { options } : {}
+    };
+  }
+  /**
+   * @returns {object} This dataset file as a JSON object.
+   */
+  toJSON() {
+    return this.file;
+  }
+}
+class VitessceConfigDataset {
+  /**
+   * Construct a new dataset definition instance.
+   * @param {string} uid The unique ID for the dataset.
+   * @param {string} name The name of the dataset.
+   * @param {string} description A description for the dataset.
+   */
+  constructor(uid, name, description) {
+    this.dataset = {
+      uid,
+      name,
+      description,
+      files: []
+    };
+  }
+  /**
+   * Add a file definition to the dataset.
+   * @param {object} params An object with named arguments.
+   * @param {string|undefined} params.url The URL to the file.
+   * @param {string} params.fileType The file type.
+   * @param {object|undefined} params.coordinationValues The coordination values.
+   * @param {object|array|undefined} params.options An optional object or array
+   * which may provide additional parameters to the loader class
+   * corresponding to the specified fileType.
+   * @returns {VitessceConfigDataset} This, to allow chaining.
+   */
+  addFile(params, ...args) {
+    let url;
+    let fileType;
+    let coordinationValues;
+    let options;
+    if (args.length > 0) {
+      url = params;
+      let dataType;
+      if (args.length === 2) {
+        [dataType, fileType] = args;
+      } else if (args.length === 3) {
+        [dataType, fileType, options] = args;
+      }
+    } else if (typeof params === "object") {
+      ({
+        url,
+        fileType,
+        options,
+        coordinationValues
+      } = params);
+    } else {
+      throw new Error("Expected addFile argument to be an object.");
+    }
+    this.dataset.files.push(new VitessceConfigDatasetFile(url, fileType, coordinationValues, options));
+    return this;
+  }
+  /**
+   * @returns {object} This dataset as a JSON object.
+   */
+  toJSON() {
+    return {
+      ...this.dataset,
+      files: this.dataset.files.map((f) => f.toJSON())
+    };
+  }
+}
+function useCoordinationByObjectHelper(scopes, coordinationScopes, coordinationScopesBy) {
+  function processLevel(parentType, parentScope, levelType, levelVal) {
+    var _a, _b;
+    if (Array.isArray(levelVal)) {
+      coordinationScopesBy[parentType] = {
+        ...coordinationScopesBy[parentType] || {},
+        [levelType]: {
+          ...((_a = coordinationScopesBy[parentType]) == null ? void 0 : _a[levelType]) || {},
+          [parentScope.cScope]: levelVal.map((childVal) => childVal.scope.cScope)
+        }
+      };
+      levelVal.forEach((childVal) => {
+        if (childVal.children) {
+          Object.entries(childVal.children).forEach(([nextLevelType, nextLevelVal]) => processLevel(levelType, childVal.scope, nextLevelType, nextLevelVal));
+        }
+      });
+    } else {
+      coordinationScopesBy[parentType] = {
+        ...coordinationScopesBy[parentType] || {},
+        [levelType]: {
+          ...((_b = coordinationScopesBy[parentType]) == null ? void 0 : _b[levelType]) || {},
+          [parentScope.cScope]: levelVal.scope.cScope
+        }
+      };
+      if (levelVal.children) {
+        Object.entries(levelVal.children).forEach(([nextLevelType, nextLevelVal]) => processLevel(levelType, levelVal.scope, nextLevelType, nextLevelVal));
+      }
+    }
+  }
+  Object.entries(scopes).forEach(([topLevelType, topLevelVal]) => {
+    if (Array.isArray(topLevelVal)) {
+      coordinationScopes[topLevelType] = topLevelVal.map((levelVal) => levelVal.scope.cScope);
+      topLevelVal.forEach((levelVal) => {
+        if (levelVal.children) {
+          Object.entries(levelVal.children).forEach(([nextLevelType, nextLevelVal]) => processLevel(topLevelType, levelVal.scope, nextLevelType, nextLevelVal));
+        }
+      });
+    } else {
+      coordinationScopes[topLevelType] = topLevelVal.scope.cScope;
+      if (topLevelVal.children) {
+        Object.entries(topLevelVal.children).forEach(([nextLevelType, nextLevelVal]) => processLevel(topLevelType, topLevelVal.scope, nextLevelType, nextLevelVal));
+      }
+    }
+  });
+  return [coordinationScopes, coordinationScopesBy];
+}
+class VitessceConfigView {
+  /**
+   * Construct a new view instance.
+   * @param {string} component The name of the Vitessce component type.
+   * @param {object} coordinationScopes A mapping from coordination type
+   * names to coordination scope names.
+   * @param {number} x The x-coordinate of the view in the layout.
+   * @param {number} y The y-coordinate of the view in the layout.
+   * @param {number} w The width of the view in the layout.
+   * @param {number} h The height of the view in the layout.
+   */
+  constructor(component, coordinationScopes, x, y, w, h) {
+    this.view = {
+      component,
+      coordinationScopes,
+      coordinationScopesBy: void 0,
+      x,
+      y,
+      w,
+      h
+    };
+  }
+  /**
+   * Attach coordination scopes to this view.
+   * @param  {...VitessceConfigCoordinationScope} args A variable number of
+   * coordination scope instances.
+   * @returns {VitessceConfigView} This, to allow chaining.
+   */
+  useCoordination(...args) {
+    const cScopes = args;
+    cScopes.forEach((cScope) => {
+      this.view.coordinationScopes[cScope.cType] = cScope.cScope;
+    });
+    return this;
+  }
+  /**
+   * Attach potentially multi-level coordination scopes to this view.
+   * @param {object} scopes A value returned by `VitessceConfig.addCoordinationByObject`.
+   * Not intended to be a manually-constructed object.
+   * @returns {VitessceConfigView} This, to allow chaining.
+   */
+  useCoordinationByObject(scopes) {
+    if (!this.view.coordinationScopes) {
+      this.view.coordinationScopes = {};
+    }
+    if (!this.view.coordinationScopesBy) {
+      this.view.coordinationScopesBy = {};
+    }
+    const [nextCoordinationScopes, nextCoordinationScopesBy] = useCoordinationByObjectHelper(scopes, this.view.coordinationScopes, this.view.coordinationScopesBy);
+    this.view.coordinationScopes = nextCoordinationScopes;
+    this.view.coordinationScopesBy = nextCoordinationScopesBy;
+    return this;
+  }
+  /**
+   * Attach meta coordination scopes to this view.
+   * @param {VitessceConfigMetaCoordinationScope} metaScope A meta coordination scope instance.
+   * @returns {VitessceConfigView} This, to allow chaining.
+   */
+  useMetaCoordination(metaScope) {
+    if (!this.view.coordinationScopes) {
+      this.view.coordinationScopes = {};
+    }
+    this.view.coordinationScopes[CoordinationType$1.META_COORDINATION_SCOPES] = [
+      ...this.view.coordinationScopes[CoordinationType$1.META_COORDINATION_SCOPES] || [],
+      metaScope.metaScope.cScope
+    ];
+    this.view.coordinationScopes[CoordinationType$1.META_COORDINATION_SCOPES_BY] = [
+      ...this.view.coordinationScopes[CoordinationType$1.META_COORDINATION_SCOPES_BY] || [],
+      metaScope.metaByScope.cScope
+    ];
+    return this;
+  }
+  /**
+    * Set the x, y, w, h values for this view.
+    * @param {number} x The x-coordinate of the view in the layout.
+    * @param {number} y The y-coordinate of the view in the layout.
+    * @param {number} w The width of the view in the layout.
+    * @param {number} h The height of the view in the layout.
+    * @returns {VitessceConfigView} This, to allow chaining.
+    */
+  setXYWH(x, y, w, h) {
+    this.view.x = x;
+    this.view.y = y;
+    this.view.w = w;
+    this.view.h = h;
+    return this;
+  }
+  /**
+   * Set props for this view.
+   * @returns {VitessceConfigView} This, to allow chaining.
+   */
+  setProps(props) {
+    this.view.props = {
+      ...this.view.props || {},
+      ...props
+    };
+    return this;
+  }
+  /**
+   * @returns {object} This view as a JSON object.
+   */
+  toJSON() {
+    return this.view;
+  }
+}
+class VitessceConfigViewHConcat {
+  constructor(views) {
+    this.views = views;
+  }
+}
+class VitessceConfigViewVConcat {
+  constructor(views) {
+    this.views = views;
+  }
+}
+class CoordinationLevel {
+  constructor(value) {
+    this.value = value;
+    this.cachedValue = null;
+  }
+  setCached(processedLevel) {
+    this.cachedValue = processedLevel;
+  }
+  getCached() {
+    return this.cachedValue;
+  }
+  isCached() {
+    return this.cachedValue !== null;
+  }
+}
+class VitessceConfigCoordinationScope {
+  /**
+   * Construct a new coordination scope instance.
+   * @param {string} cType The coordination type for this coordination scope.
+   * @param {string} cScope The name of the coordination scope.
+   * @param {[any]} cValue Optional. The coordination value of the coordination scope.
+   */
+  constructor(cType, cScope, cValue = null) {
+    this.cType = cType;
+    this.cScope = cScope;
+    this.cValue = cValue;
+  }
+  /**
+   * Set the coordination value of the coordination scope.
+   * @param {any} cValue The value to set.
+   * @returns {VitessceConfigCoordinationScope} This, to allow chaining.
+   */
+  setValue(cValue) {
+    this.cValue = cValue;
+    return this;
+  }
+}
+class VitessceConfigMetaCoordinationScope {
+  /**
+   * Construct a new coordination scope instance.
+   * @param {string} metaScope The name of the coordination scope for metaCoordinationScopes.
+   * @param {string} metaByScope The name of the coordination scope for metaCoordinationScopesBy.
+   */
+  constructor(metaScope, metaByScope) {
+    this.metaScope = new VitessceConfigCoordinationScope(CoordinationType$1.META_COORDINATION_SCOPES, metaScope);
+    this.metaByScope = new VitessceConfigCoordinationScope(CoordinationType$1.META_COORDINATION_SCOPES_BY, metaByScope);
+  }
+  /**
+   * Attach coordination scopes to this meta scope.
+   * @param  {...VitessceConfigCoordinationScope} args A variable number of
+   * coordination scope instances.
+   * @returns {VitessceConfigMetaCoordinationScope} This, to allow chaining.
+   */
+  useCoordination(...args) {
+    const cScopes = args;
+    const metaScopesVal = this.metaScope.cValue;
+    cScopes.forEach((cScope) => {
+      metaScopesVal[cScope.cType] = cScope.cScope;
+    });
+    this.metaScope.setValue(metaScopesVal);
+    return this;
+  }
+  /**
+   * Attach potentially multi-level coordination scopes to this meta coordination
+   * scope instance.
+   * @param {object} scopes A value returned by `VitessceConfig.addCoordinationByObject`.
+   * Not intended to be a manually-constructed object.
+   * @returns {VitessceConfigView} This, to allow chaining.
+   */
+  useCoordinationByObject(scopes) {
+    if (!this.metaScope.cValue) {
+      this.metaScope.setValue({});
+    }
+    if (!this.metaByScope.cValue) {
+      this.metaByScope.setValue({});
+    }
+    const [metaScopesVal, metaByScopesVal] = useCoordinationByObjectHelper(scopes, this.metaScope.cValue, this.metaByScope.cValue);
+    this.metaScope.setValue(metaScopesVal);
+    this.metaByScope.setValue(metaByScopesVal);
+    return this;
+  }
+}
+class VitessceConfig {
+  /**
+   * Construct a new view config instance.
+   * @param {object} params An object with named arguments.
+   * @param {string} params.schemaVersion The view config schema version. Required.
+   * @param {string} params.name A name for the config. Optional.
+   * @param {string|undefined} params.description A description for the config. Optional.
+   */
+  constructor(params, ...args) {
+    let name;
+    let description;
+    let schemaVersion;
+    if (typeof params === "string") {
+      schemaVersion = "1.0.7";
+      name = params || "";
+      if (args.length === 1) {
+        [description] = args;
+      } else if (args.length > 1) {
+        throw new Error("Expected only one VitessceConfig constructor argument.");
+      }
+    } else if (typeof params === "object") {
+      ({ schemaVersion, name, description } = params);
+      if (!name) {
+        throw new Error("Expected params.name argument in VitessceConfig constructor");
+      }
+      if (!schemaVersion) {
+        throw new Error("Expected params.schemaVersion argument in VitessceConfig constructor");
+      }
+    } else {
+      throw new Error("Expected VitessceConfig constructor argument to be an object.");
+    }
+    this.config = {
+      version: schemaVersion,
+      name,
+      description,
+      datasets: [],
+      coordinationSpace: {},
+      layout: [],
+      initStrategy: "auto"
+    };
+    this.getNextScope = getNextScope;
+  }
+  /**
+   * Add a new dataset to the config.
+   * @param {string} name A name for the dataset. Optional.
+   * @param {string} description A description for the dataset. Optional.
+   * @param {object} options Extra parameters to be used internally. Optional.
+   * @param {string} options.uid Override the automatically-generated dataset ID.
+   * Intended for internal usage by the VitessceConfig.fromJSON code.
+   * @returns {VitessceConfigDataset} A new dataset instance.
+   */
+  addDataset(name = void 0, description = void 0, options = void 0) {
+    const { uid } = options || {};
+    const prevDatasetUids = this.config.datasets.map((d) => d.dataset.uid);
+    const nextUid = uid || this.getNextScope(prevDatasetUids);
+    const newDataset = new VitessceConfigDataset(nextUid, name, description);
+    this.config.datasets.push(newDataset);
+    const [newScope] = this.addCoordination(CoordinationType$1.DATASET);
+    newScope.setValue(nextUid);
+    return newDataset;
+  }
+  /**
+   * Add a new view to the config.
+   * @param {VitessceConfigDataset} dataset The dataset instance which defines the data
+   * that will be displayed in the view.
+   * @param {string} component A component name, such as "scatterplot" or "spatial".
+   * @param {object} options Extra options for the component.
+   * @param {number} options.x The x-coordinate for the view in the grid layout.
+   * @param {number} options.y The y-coordinate for the view in the grid layout.
+   * @param {number} options.w The width for the view in the grid layout.
+   * @param {number} options.h The height for the view in the grid layout.
+   * @param {number} options.mapping A convenience parameter for setting the EMBEDDING_TYPE
+   * coordination value. Only applicable if the component is "scatterplot".
+   * @returns {VitessceConfigView} A new view instance.
+   */
+  addView(dataset, component, options) {
+    const { x = 0, y = 0, w = 1, h = 1, mapping = null } = options || {};
+    const datasetMatches = this.config.coordinationSpace[CoordinationType$1.DATASET] ? Object.entries(this.config.coordinationSpace[CoordinationType$1.DATASET]).filter(([scopeName, datasetScope2]) => datasetScope2.cValue === dataset.dataset.uid).map(([scopeName]) => scopeName) : [];
+    let datasetScope;
+    if (datasetMatches.length === 1) {
+      [datasetScope] = datasetMatches;
+    } else {
+      throw new Error("No coordination scope matching the dataset parameter could be found in the coordination space.");
+    }
+    const coordinationScopes = {
+      [CoordinationType$1.DATASET]: datasetScope
+    };
+    const newView = new VitessceConfigView(component, coordinationScopes, x, y, w, h);
+    if (mapping) {
+      const [etScope] = this.addCoordination(CoordinationType$1.EMBEDDING_TYPE);
+      etScope.setValue(mapping);
+      newView.useCoordination(etScope);
+    }
+    this.config.layout.push(newView);
+    return newView;
+  }
+  /**
+   * Get an array of new coordination scope instances corresponding to coordination types
+   * of interest.
+   * @param {...string} args A variable number of coordination type names.
+   * @returns {VitessceConfigCoordinationScope[]} An array of coordination scope instances.
+   */
+  addCoordination(...args) {
+    const cTypes = args;
+    const result = [];
+    cTypes.forEach((cType) => {
+      const prevScopes = this.config.coordinationSpace[cType] ? Object.keys(this.config.coordinationSpace[cType]) : [];
+      const scope = new VitessceConfigCoordinationScope(cType, this.getNextScope(prevScopes));
+      if (!this.config.coordinationSpace[scope.cType]) {
+        this.config.coordinationSpace[scope.cType] = {};
+      }
+      this.config.coordinationSpace[scope.cType][scope.cScope] = scope;
+      result.push(scope);
+    });
+    return result;
+  }
+  /**
+   * Initialize a new meta coordination scope in the coordination space,
+   * and get a reference to it in the form of a meta coordination scope instance.
+   * @returns {VitessceConfigMetaCoordinationScope} A new meta coordination scope instance.
+   */
+  addMetaCoordination() {
+    const prevMetaScopes = this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES] ? Object.keys(this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES]) : [];
+    const prevMetaByScopes = this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES_BY] ? Object.keys(this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES_BY]) : [];
+    const metaContainer = new VitessceConfigMetaCoordinationScope(this.getNextScope(prevMetaScopes), this.getNextScope(prevMetaByScopes));
+    if (!this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES]) {
+      this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES] = {};
+    }
+    if (!this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES_BY]) {
+      this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES_BY] = {};
+    }
+    this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES][metaContainer.metaScope.cScope] = metaContainer.metaScope;
+    this.config.coordinationSpace[CoordinationType$1.META_COORDINATION_SCOPES_BY][metaContainer.metaByScope.cScope] = metaContainer.metaByScope;
+    return metaContainer;
+  }
+  /**
+   * Set up the initial values for multi-level coordination in the coordination space.
+   * Get a reference to these values to pass to the `useCoordinationByObject` method
+   * of either view or meta coordination scope instances.
+   * @param {object} input A (potentially nested) object with coordination types as keys
+   * and values being either the initial coordination value, a `VitessceConfigCoordinationScope`
+   * instance, or a `CoordinationLevel` instance.
+   * The CL function takes an array of objects as its argument, and returns a CoordinationLevel
+   * instance, to support nesting.
+   * @returns {object} A (potentially nested) object with coordination types as keys and values
+   * being either { scope }, { scope, children }, or an array of these. Not intended to be
+   * manipulated before being passed to a `useCoordinationByObject` function.
+   */
+  addCoordinationByObject(input) {
+    const processLevel = (level) => {
+      const result = {};
+      if (level === null) {
+        return result;
+      }
+      Object.entries(level).forEach(([cType, nextLevelOrInitialValue]) => {
+        if (nextLevelOrInitialValue instanceof CoordinationLevel) {
+          const nextLevel = nextLevelOrInitialValue.value;
+          if (nextLevelOrInitialValue.isCached()) {
+            result[cType] = nextLevelOrInitialValue.getCached();
+          } else if (Array.isArray(nextLevel)) {
+            const processedLevel = nextLevel.map((nextEl) => {
+              const [dummyScope] = this.addCoordination(cType);
+              dummyScope.setValue("__dummy__");
+              return {
+                scope: dummyScope,
+                children: processLevel(nextEl)
+              };
+            });
+            nextLevelOrInitialValue.setCached(processedLevel);
+            result[cType] = processedLevel;
+          } else {
+            const nextEl = nextLevel;
+            const [dummyScope] = this.addCoordination(cType);
+            dummyScope.setValue("__dummy__");
+            const processedLevel = {
+              scope: dummyScope,
+              children: processLevel(nextEl)
+            };
+            nextLevelOrInitialValue.setCached(processedLevel);
+            result[cType] = processedLevel;
+          }
+        } else {
+          const initialValue = nextLevelOrInitialValue;
+          if (initialValue instanceof VitessceConfigCoordinationScope) {
+            result[cType] = { scope: initialValue };
+          } else {
+            const [scope] = this.addCoordination(cType);
+            scope.setValue(initialValue);
+            result[cType] = { scope };
+          }
+        }
+      });
+      return result;
+    };
+    const output = processLevel(input);
+    return output;
+  }
+  /**
+   * A convenience function for setting up new coordination scopes across a set of views.
+   * @param {VitessceConfigView[]} views An array of view objects to link together.
+   * @param {string[]} cTypes The coordination types on which to coordinate the views.
+   * @param {any[]} cValues Initial values corresponding to each coordination type.
+   * Should have the same length as the cTypes array. Optional.
+   * @returns {VitessceConfig} This, to allow chaining.
+   */
+  linkViews(views, cTypes, cValues = null) {
+    const cScopes = this.addCoordination(...cTypes);
+    views.forEach((view) => {
+      cScopes.forEach((cScope) => {
+        view.useCoordination(cScope);
+      });
+    });
+    if (Array.isArray(cValues) && cValues.length === cTypes.length) {
+      cScopes.forEach((cScope, i) => {
+        cScope.setValue(cValues[i]);
+      });
+    }
+    return this;
+  }
+  /**
+   * A convenience function for setting up multi-level and meta-coordination scopes
+   * across a set of views.
+   * @param {VitessceConfigView[]} views An array of view objects to link together.
+   * @param {object} input A (potentially nested) object with coordination types as keys
+   * and values being either the initial coordination value, a `VitessceConfigCoordinationScope`
+   * instance, or a `CoordinationLevel` instance.
+   * The CL function takes an array of objects as its argument, and returns a CoordinationLevel
+   * instance, to support nesting.
+   * @param {object|null} options
+   * @param {bool} options.meta Should meta-coordination be used? Optional.
+   * By default, true.
+   * @param {string|null} options.scopePrefix A prefix to add to all
+   * coordination scope names. Optional.
+   * @returns {VitessceConfig} This, to allow chaining.
+   */
+  linkViewsByObject(views, input, options = null) {
+    const { meta = true, scopePrefix = null } = options || {};
+    if (scopePrefix) {
+      this.getNextScope = createPrefixedGetNextScopeNumeric(scopePrefix);
+    }
+    const scopes = this.addCoordinationByObject(input);
+    if (meta) {
+      const metaScope = this.addMetaCoordination();
+      metaScope.useCoordinationByObject(scopes);
+      views.forEach((view) => {
+        view.useMetaCoordination(metaScope);
+      });
+    } else {
+      views.forEach((view) => {
+        view.useCoordinationByObject(scopes);
+      });
+    }
+    if (scopePrefix) {
+      this.getNextScope = getNextScope;
+    }
+    return this;
+  }
+  /**
+   * Set the value for a coordination scope.
+   * If a coordination object for the coordination type does not yet exist
+   * in the coordination space, it will be created.
+   * @param {string} cType The coordination type.
+   * @param {string} cScope The coordination scope.
+   * @param {any} cValue The initial value for the coordination scope.
+   * @returns {VitessceConfigCoordinationScope} A coordination scope instance.
+   */
+  setCoordinationValue(cType, cScope, cValue) {
+    const scope = new VitessceConfigCoordinationScope(cType, cScope, cValue);
+    if (!this.config.coordinationSpace[scope.cType]) {
+      this.config.coordinationSpace[scope.cType] = {};
+    }
+    this.config.coordinationSpace[scope.cType][scope.cScope] = scope;
+    return scope;
+  }
+  /**
+   * Set the layout of views.
+   * @param {VitessceConfigView|VitessceConfigViewHConcat|VitessceConfigViewVConcat} viewConcat A
+   * view or a concatenation of views.
+   * @returns {VitessceConfig} This, to allow chaining.
+   */
+  layout(viewConcat) {
+    function layoutAux(obj, xMin, xMax, yMin, yMax) {
+      const w = xMax - xMin;
+      const h = yMax - yMin;
+      if (obj instanceof VitessceConfigView) {
+        obj.setXYWH(xMin, yMin, w, h);
+      } else if (obj instanceof VitessceConfigViewHConcat) {
+        const { views } = obj;
+        const numViews = views.length;
+        views.forEach((view, i) => {
+          layoutAux(view, xMin + w / numViews * i, xMin + w / numViews * (i + 1), yMin, yMax);
+        });
+      } else if (obj instanceof VitessceConfigViewVConcat) {
+        const { views } = obj;
+        const numViews = views.length;
+        views.forEach((view, i) => {
+          layoutAux(view, xMin, xMax, yMin + h / numViews * i, yMin + h / numViews * (i + 1));
+        });
+      }
+    }
+    layoutAux(viewConcat, 0, 12, 0, 12);
+    return this;
+  }
+  /**
+   * Convert this instance to a JSON object that can be passed to the Vitessce component.
+   * @returns {object} The view config as a JSON object.
+   */
+  toJSON() {
+    return {
+      ...this.config,
+      datasets: this.config.datasets.map((d) => d.toJSON()),
+      coordinationSpace: fromEntries(Object.entries(this.config.coordinationSpace).map(([cType, cScopes]) => [
+        cType,
+        fromEntries(Object.entries(cScopes).map(([cScopeName, cScope]) => [
+          cScopeName,
+          cScope.cValue
+        ]))
+      ])),
+      layout: this.config.layout.map((c) => c.toJSON())
+    };
+  }
+  /**
+   * Create a VitessceConfig instance from an existing view config, to enable
+   * manipulation with the JavaScript API.
+   * @param {object} config An existing Vitessce view config as a JSON object.
+   * @returns {VitessceConfig} A new config instance, with values set to match
+   * the config parameter.
+   */
+  static fromJSON(config2) {
+    const { name, description, version: schemaVersion } = config2;
+    const vc = new VitessceConfig({ schemaVersion, name, description });
+    config2.datasets.forEach((d) => {
+      const newDataset = vc.addDataset(d.name, d.description, { uid: d.uid });
+      d.files.forEach((f) => {
+        newDataset.addFile({
+          url: f.url,
+          fileType: f.fileType,
+          coordinationValues: f.coordinationValues,
+          options: f.options
+        });
+      });
+    });
+    Object.keys(config2.coordinationSpace).forEach((cType) => {
+      if (cType !== CoordinationType$1.DATASET) {
+        const cObj = config2.coordinationSpace[cType];
+        vc.config.coordinationSpace[cType] = {};
+        Object.entries(cObj).forEach(([cScopeName, cScopeValue]) => {
+          const scope = new VitessceConfigCoordinationScope(cType, cScopeName);
+          scope.setValue(cScopeValue);
+          vc.config.coordinationSpace[cType][cScopeName] = scope;
+        });
+      }
+    });
+    config2.layout.forEach((c) => {
+      const newView = new VitessceConfigView(c.component, c.coordinationScopes, c.x, c.y, c.w, c.h);
+      vc.config.layout.push(newView);
+    });
+    return vc;
+  }
+}
+function getCoordinationSpaceAndScopes(partialCoordinationValues, scopePrefix) {
+  const vc = new VitessceConfig({ schemaVersion: "1.0.16", name: "__dummy__" });
+  vc.getNextScope = createPrefixedGetNextScopeNumeric(scopePrefix);
+  const dataset = vc.addDataset("__dummy__");
+  const v1 = vc.addView(dataset, "__dummy__");
+  vc.linkViewsByObject([v1], partialCoordinationValues, { meta: true });
+  const vcJson = vc.toJSON();
+  const { coordinationSpace } = vcJson;
+  const { coordinationScopes } = vcJson.layout[0];
+  const { coordinationScopesBy } = vcJson.layout[0];
+  return {
+    coordinationSpace,
+    coordinationScopes,
+    coordinationScopesBy
+  };
+}
 function getMetaScope(coordinationScopes, coordinationSpace, parameter) {
   let latestMetaScope;
   if (coordinationSpace) {
@@ -36193,7 +36819,8 @@ function getMetaScope(coordinationScopes, coordinationSpace, parameter) {
     if (metaScopes && metaSpace) {
       const metaScopesArr = Array.isArray(metaScopes) ? metaScopes : [metaScopes];
       metaScopesArr.forEach((metaScope) => {
-        if (metaSpace[metaScope][parameter]) {
+        var _a;
+        if ((_a = metaSpace[metaScope]) == null ? void 0 : _a[parameter]) {
           latestMetaScope = metaScope;
         }
       });
@@ -36419,7 +37046,15 @@ function getScopes(coordinationScopes, metaSpace) {
     if (metaScopes && metaSpace) {
       const metaScopesArr = Array.isArray(metaScopes) ? metaScopes : [metaScopes];
       metaScopesArr.forEach((metaScope) => {
-        result = merge$1(result, metaSpace[metaScope]);
+        let o1 = result;
+        const o2 = metaSpace[metaScope] || {};
+        Object.entries(o2).forEach(([cType, cScope]) => {
+          o1 = {
+            ...o1,
+            [cType]: cScope
+          };
+        });
+        result = o1;
       });
     }
   }
@@ -36432,7 +37067,26 @@ function getScopesBy(coordinationScopes, coordinationScopesBy, metaSpaceBy) {
     if (metaSpaceBy && metaScopesBy) {
       const metaScopesArr = Array.isArray(metaScopesBy) ? metaScopesBy : [metaScopesBy];
       metaScopesArr.forEach((metaScope) => {
-        result = merge$1(result, metaSpaceBy[metaScope]);
+        let o1 = result;
+        const o2 = metaSpaceBy[metaScope] || {};
+        Object.entries(o2).forEach(([primaryType, primaryObj]) => {
+          Object.entries(primaryObj).forEach(([secondaryType, secondaryObj]) => {
+            Object.entries(secondaryObj).forEach(([primaryScope, secondaryScopeVal]) => {
+              var _a;
+              o1 = {
+                ...o1,
+                [primaryType]: {
+                  ...(o1 == null ? void 0 : o1[primaryType]) || {},
+                  [secondaryType]: {
+                    ...((_a = o1 == null ? void 0 : o1[primaryType]) == null ? void 0 : _a[secondaryType]) || {},
+                    [primaryScope]: secondaryScopeVal
+                  }
+                }
+              };
+            });
+          });
+        });
+        result = o1;
       });
     }
   }
@@ -36501,6 +37155,83 @@ const createViewConfigStore = (initialLoaders, initialConfig) => create2((set2)
       }
     };
   }),
+  mergeCoordination: (newCoordinationValues, scopePrefix, viewUid) => set2((state) => {
+    const { coordinationSpace, layout: layout2 } = state.viewConfig;
+    const {
+      coordinationSpace: newCoordinationSpace,
+      coordinationScopes
+    } = getCoordinationSpaceAndScopes(newCoordinationValues, scopePrefix);
+    Object.entries(newCoordinationSpace).forEach(([coordinationType, coordinationObj]) => {
+      if (coordinationType === CoordinationType$1.META_COORDINATION_SCOPES) {
+        Object.entries(coordinationObj).forEach(([coordinationScope, coordinationValue]) => {
+          var _a;
+          coordinationSpace[coordinationType] = {
+            ...coordinationSpace[coordinationType],
+            [coordinationScope]: {
+              ...coordinationValue,
+              ...((_a = coordinationSpace[coordinationType]) == null ? void 0 : _a[coordinationScope]) || {}
+            }
+          };
+        });
+      } else if (coordinationType === CoordinationType$1.META_COORDINATION_SCOPES_BY) {
+        Object.entries(coordinationObj).forEach(([coordinationScope, coordinationValue]) => {
+          Object.entries(coordinationValue).forEach(([primaryType, primaryObj]) => {
+            Object.entries(primaryObj).forEach(([secondaryType, secondaryObj]) => {
+              var _a, _b, _c, _d, _e, _f;
+              coordinationSpace[coordinationType] = {
+                ...coordinationSpace[coordinationType],
+                [coordinationScope]: {
+                  ...((_a = coordinationSpace[coordinationType]) == null ? void 0 : _a[coordinationScope]) || {},
+                  [primaryType]: {
+                    ...((_c = (_b = coordinationSpace[coordinationType]) == null ? void 0 : _b[coordinationScope]) == null ? void 0 : _c[primaryType]) || {},
+                    [secondaryType]: {
+                      ...secondaryObj,
+                      ...((_f = (_e = (_d = coordinationSpace[coordinationType]) == null ? void 0 : _d[coordinationScope]) == null ? void 0 : _e[primaryType]) == null ? void 0 : _f[secondaryType]) || {}
+                    }
+                  }
+                }
+              };
+            });
+          });
+        });
+      } else {
+        coordinationSpace[coordinationType] = {
+          ...coordinationObj,
+          // Existing coordination values should be preserved,
+          // so that user-defined values take precedence over auto-initialization values.
+          ...coordinationSpace[coordinationType] || {}
+        };
+      }
+    });
+    const newViewConfig = {
+      ...state.viewConfig,
+      coordinationSpace: {
+        ...coordinationSpace
+      },
+      layout: layout2.map((viewObj) => {
+        if (viewObj.uid === viewUid) {
+          return {
+            ...viewObj,
+            coordinationScopes: {
+              ...viewObj.coordinationScopes,
+              [CoordinationType$1.META_COORDINATION_SCOPES]: [
+                ...coordinationScopes[CoordinationType$1.META_COORDINATION_SCOPES] || [],
+                ...viewObj.coordinationScopes[CoordinationType$1.META_COORDINATION_SCOPES] || []
+              ],
+              [CoordinationType$1.META_COORDINATION_SCOPES_BY]: [
+                ...coordinationScopes[CoordinationType$1.META_COORDINATION_SCOPES_BY] || [],
+                ...viewObj.coordinationScopes[CoordinationType$1.META_COORDINATION_SCOPES_BY] || []
+              ]
+            }
+          };
+        }
+        return viewObj;
+      })
+    };
+    return {
+      viewConfig: newViewConfig
+    };
+  }),
   removeImageChannelInMetaCoordinationScopes: (coordinationScopesRaw, layerScope, channelScope) => set2((state) => {
     const { coordinationSpace } = state.viewConfig;
     return {
@@ -37008,6 +37739,9 @@ function useChangeLayout() {
 function useSetLoaders() {
   return useViewConfigStore((state) => state.setLoaders);
 }
+function useMergeCoordination() {
+  return useViewConfigStore((state) => state.mergeCoordination);
+}
 function useSetViewConfig(viewConfigStoreApi) {
   const setViewConfigRef = useRef(viewConfigStoreApi.getState().setViewConfig);
   const setViewConfig = setViewConfigRef.current;
@@ -43154,7 +43888,7 @@ function useRowHeight(config2, initialRowHeight, height2, margin2, padding2) {
   return [rowHeight, containerRef];
 }
 function withDefaults(coordinationValues, dataType, fileType, datasetUid, defaultCoordinationValues) {
-  const defaultKeys = DATA_TYPE_COORDINATION_VALUE_USAGE[dataType].filter((k) => Object.keys(defaultCoordinationValues).includes(k) && defaultCoordinationValues[k] && !Object.keys(coordinationValues).includes(k));
+  const defaultKeys = DATA_TYPE_COORDINATION_VALUE_USAGE[dataType].filter((k) => Object.keys(defaultCoordinationValues).includes(k) && !Object.keys(coordinationValues).includes(k));
   const defaultValues = pick$1(defaultCoordinationValues, defaultKeys);
   const coordinationValuesWithDefaults = {
     ...defaultValues,
@@ -43790,7 +44524,8 @@ function VitessceGrid(props) {
     isBounded,
     viewTypes,
     fileTypes,
-    coordinationTypes
+    coordinationTypes,
+    stores
   } = props;
   const [rowHeight, containerRef] = useRowHeight(config2, initialRowHeight, height2, margin, padding);
   const onResize = useEmitGridResize();
@@ -43820,7 +44555,8 @@ function VitessceGrid(props) {
         config2.datasets,
         config2.description,
         fileTypes,
-        coordinationTypes
+        coordinationTypes,
+        stores
       );
       newConfig = config2;
     }
@@ -44289,7 +45025,8 @@ function VitS(props) {
         rowHeight,
         height: height2,
         theme,
-        isBounded
+        isBounded,
+        stores
       }
     ),
     /* @__PURE__ */ jsxRuntimeExports.jsx(
@@ -44687,7 +45424,7 @@ async function dataQueryFn(ctx) {
     if (!payload)
       return placeholderObject;
     const { data, url, coordinationValues } = payload;
-    const urls = Array.isArray(url) ? url : [{ url, name: dataType }];
+    const urls = (Array.isArray(url) ? url : [{ url, name: dataType }]).filter((d) => d.url);
     return { data, coordinationValues, urls };
   }
   if (isRequired) {
@@ -44733,7 +45470,7 @@ function useDataType(dataType, loaders, dataset, isRequired, coordinationSetters
   const dataStatus = isFetching ? STATUS.LOADING : status;
   return [loadedData, dataStatus, urls];
 }
-function useDataTypeMulti(dataType, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOnObj) {
+function useDataTypeMulti(dataType, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOnObj, mergeCoordination, viewUid) {
   const placeholderObject = useMemo(() => ({}), []);
   const setWarning = useSetWarning();
   const matchOnEntries = matchOnObj ? Object.entries(matchOnObj) : [];
@@ -44759,15 +45496,25 @@ function useDataTypeMulti(dataType, loaders, dataset, isRequired, coordinationSe
   const dataStatus = anyLoading ? STATUS.LOADING : anyError ? STATUS.ERROR : STATUS.SUCCESS;
   const isSuccess = dataStatus === STATUS.SUCCESS;
   useEffect(() => {
-    dataQueries.map((q) => {
+    dataQueries.filter((q) => {
       var _a;
-      return (_a = q.data) == null ? void 0 : _a.coordinationValues;
-    }).filter((v) => Boolean(v)).forEach((coordinationValues) => {
-      initCoordinationSpace(
-        coordinationValues,
-        coordinationSetters,
-        initialCoordinationValues
-      );
+      return Boolean((_a = q.data) == null ? void 0 : _a.coordinationValues);
+    }).forEach((q) => {
+      const { coordinationValues } = q.data;
+      if (mergeCoordination) {
+        mergeCoordination(
+          coordinationValues,
+          // Auto-generate based on the dataset and data type.
+          getInitialCoordinationScopePrefix(dataset, dataType),
+          viewUid
+        );
+      } else {
+        initCoordinationSpace(
+          coordinationValues,
+          coordinationSetters,
+          initialCoordinationValues
+        );
+      }
     });
   }, [isSuccess]);
   useEffect(() => {
@@ -45046,7 +45793,7 @@ function useObsFeatureMatrixIndices(loaders, dataset, isRequired, matchOn) {
               obsIndex: payloadData2.rows,
               featureIndex: payloadData2.cols
             },
-            urls: [{ url: url2, name: DataType$1.OBS_FEATURE_MATRIX }]
+            urls: url2 ? [{ url: url2, name: DataType$1.OBS_FEATURE_MATRIX }] : null
           };
         }
         const payload = await loader.load();
@@ -45080,7 +45827,7 @@ function useObsFeatureMatrixIndices(loaders, dataset, isRequired, matchOn) {
   }, [error, setWarning]);
   return [loadedData, dataStatus, urls];
 }
-function useMultiObsPoints(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+function useMultiObsPoints(coordinationScopes, coordinationScopesBy, loaders, dataset, mergeCoordination, viewUid) {
   const obsTypeCoordination = useComplexCoordination(
     [
       CoordinationType$1.OBS_TYPE
@@ -45103,11 +45850,13 @@ function useMultiObsPoints(coordinationScopes, coordinationScopesBy, loaders, da
     false,
     {},
     {},
-    matchOnObj
+    matchOnObj,
+    mergeCoordination,
+    viewUid
   );
   return [obsPointsData, obsPointsDataStatus, obsPointsUrls];
 }
-function useMultiObsSpots(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+function useMultiObsSpots(coordinationScopes, coordinationScopesBy, loaders, dataset, mergeCoordination, viewUid) {
   const obsTypeCoordination = useComplexCoordination(
     [
       CoordinationType$1.OBS_TYPE
@@ -45130,7 +45879,9 @@ function useMultiObsSpots(coordinationScopes, coordinationScopesBy, loaders, dat
     false,
     {},
     {},
-    matchOnObj
+    matchOnObj,
+    mergeCoordination,
+    viewUid
   );
   return [obsSpotsData, obsSpotsDataStatus, obsSpotsUrls];
 }
@@ -45183,7 +45934,7 @@ function useMultiObsLabels(coordinationScopes, obsType, loaders, dataset) {
   );
   return [obsLabelsTypes, obsLabelsData, obsLabelsDataStatus, obsLabelsUrls];
 }
-function useMultiObsSegmentations(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+function useMultiObsSegmentations(coordinationScopes, coordinationScopesBy, loaders, dataset, mergeCoordination, viewUid) {
   const imageCoordination = useComplexCoordination(
     [
       CoordinationType$1.FILE_UID
@@ -45210,11 +45961,13 @@ function useMultiObsSegmentations(coordinationScopes, coordinationScopesBy, load
     false,
     {},
     {},
-    matchOnObj
+    matchOnObj,
+    mergeCoordination,
+    viewUid
   );
   return [obsSegmentationsData, obsSegmentationsDataStatus, obsSegmentationsUrls];
 }
-function useMultiImages(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+function useMultiImages(coordinationScopes, coordinationScopesBy, loaders, dataset, mergeCoordination, viewUid) {
   const imageCoordination = useComplexCoordination(
     [
       CoordinationType$1.FILE_UID
@@ -45237,7 +45990,9 @@ function useMultiImages(coordinationScopes, coordinationScopesBy, loaders, datas
     false,
     {},
     {},
-    matchOnObj
+    matchOnObj,
+    mergeCoordination,
+    viewUid
   );
   return [imageData, imageDataStatus, imageUrls];
 }
@@ -45490,7 +46245,7 @@ function useFeatureSelectionMultiLevel(loaders, dataset, isRequired, matchOnObj,
     const nestedExtents = nestFeatureSelectionQueryResults(queryKeyScopeTuples, flatExtents);
     const nestedNormData = nestFeatureSelectionQueryResults(queryKeyScopeTuples, flatNormData);
     return [nestedGeneData, nestedLoadedGeneName, nestedExtents, nestedNormData];
-  }, [featureQueries.reduce((a, h) => a + h.dataUpdatedAt, 0)]);
+  }, [featureQueries.reduce((a, h) => a + h.dataUpdatedAt, 0), queryKeyScopeTuples]);
   return [geneData, loadedGeneName, extents, normData, dataStatus];
 }
 async function matrixIndicesQueryFn(ctx) {
@@ -45561,7 +46316,7 @@ function useObsFeatureMatrixIndicesMultiLevel(loaders, dataset, isRequired, matc
   const indicesData = useMemo(() => {
     const nestedIndicesData = nestQueryResults(queryKeyScopeTuples, flatIndicesData);
     return nestedIndicesData;
-  }, [indicesQueries.reduce((a, h) => a + h.dataUpdatedAt, 0)]);
+  }, [indicesQueries.reduce((a, h) => a + h.dataUpdatedAt, 0), queryKeyScopeTuples]);
   return [indicesData, dataStatus];
 }
 function useDataTypeMultiLevel(loaders, dataset, isRequired, matchOnObj, depth, dataType) {
@@ -45597,7 +46352,7 @@ function useDataTypeMultiLevel(loaders, dataset, isRequired, matchOnObj, depth,
   const locationsData = useMemo(() => {
     const nestedIndicesData = nestQueryResults(queryKeyScopeTuples, flatIndicesData);
     return nestedIndicesData;
-  }, [locationsQueries.reduce((a, h) => a + h.dataUpdatedAt, 0)]);
+  }, [locationsQueries.reduce((a, h) => a + h.dataUpdatedAt, 0), queryKeyScopeTuples]);
   return [locationsData, dataStatus];
 }
 function useObsLocationsMultiLevel(loaders, dataset, isRequired, matchOnObj, depth) {
@@ -45658,6 +46413,7 @@ function useSegmentationMultiFeatureSelection(coordinationScopes, coordinationSc
     // indirect dependencies here.
     [coordinationScopes, coordinationScopesBy]
   );
+  const useMemoDependency = Object.values(featureSelectionCoordination[0] || {}).flatMap((layerVal) => Object.values(layerVal).map((cVal) => cVal.featureSelection));
   const selections = useMemo(
     () => fromEntries(Object.entries(featureSelectionCoordination[0]).map(([layerScope, layerVal]) => [
       layerScope,
@@ -45669,7 +46425,9 @@ function useSegmentationMultiFeatureSelection(coordinationScopes, coordinationSc
     [
       coordinationScopes,
       coordinationScopesBy,
-      ...Object.values(featureSelectionCoordination[0] || {}).flatMap((layerVal) => Object.values(layerVal).map((cVal) => cVal.featureSelection))
+      // We need to ensure there are always the same number of
+      // entries in the full dependency array.
+      JSON.stringify(useMemoDependency.length > 0 ? useMemoDependency : [null])
     ]
   );
   const [
@@ -46201,6 +46959,7 @@ export {
   useInitialCoordination,
   useLoaders,
   useMatchingLoader,
+  useMergeCoordination,
   useMultiCoordinationScopes,
   useMultiCoordinationScopesNonNull,
   useMultiCoordinationScopesSecondary,