@vitessce/config 4.0.0-test.1 → 4.0.0-test.3

package/dist/index.js

@@ -0,0 +1,4601 @@
+const FileType = {
+  // Joint file types
+  ANNDATA_ZARR: "anndata.zarr",
+  ANNDATA_ZARR_ZIP: "anndata.zarr.zip",
+  SPATIALDATA_ZARR: "spatialdata.zarr",
+  SPATIALDATA_ZARR_ZIP: "spatialdata.zarr.zip",
+  // OME-Zarr
+  IMAGE_OME_ZARR: "image.ome-zarr",
+  OBS_SEGMENTATIONS_OME_ZARR: "obsSegmentations.ome-zarr",
+  // OME-Zarr - Zipped
+  IMAGE_OME_ZARR_ZIP: "image.ome-zarr.zip",
+  OBS_SEGMENTATIONS_OME_ZARR_ZIP: "obsSegmentations.ome-zarr.zip",
+  // OME-TIFF
+  IMAGE_OME_TIFF: "image.ome-tiff",
+  OBS_SEGMENTATIONS_OME_TIFF: "obsSegmentations.ome-tiff",
+  RASTER_JSON: "raster.json",
+  RASTER_OME_ZARR: "raster.ome-zarr"
+};
+const CoordinationType = {
+  META_COORDINATION_SCOPES: "metaCoordinationScopes",
+  META_COORDINATION_SCOPES_BY: "metaCoordinationScopesBy",
+  DATASET: "dataset",
+  // Other types
+  EMBEDDING_TYPE: "embeddingType",
+  SPATIAL_ZOOM: "spatialZoom",
+  SPATIAL_TARGET_X: "spatialTargetX",
+  SPATIAL_TARGET_Y: "spatialTargetY",
+  SPATIAL_IMAGE_LAYER: "spatialImageLayer",
+  SPATIAL_SEGMENTATION_LAYER: "spatialSegmentationLayer"
+};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+function commonjsRequire(path) {
+  throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+var pluralize$1 = { exports: {} };
+var pluralize = pluralize$1.exports;
+var hasRequiredPluralize;
+function requirePluralize() {
+  if (hasRequiredPluralize) return pluralize$1.exports;
+  hasRequiredPluralize = 1;
+  (function(module2, exports) {
+    (function(root, pluralize2) {
+      if (typeof commonjsRequire === "function" && true && true) {
+        module2.exports = pluralize2();
+      } else {
+        root.pluralize = pluralize2();
+      }
+    })(pluralize, function() {
+      var pluralRules = [];
+      var singularRules = [];
+      var uncountables = {};
+      var irregularPlurals = {};
+      var irregularSingles = {};
+      function sanitizeRule(rule) {
+        if (typeof rule === "string") {
+          return new RegExp("^" + rule + "$", "i");
+        }
+        return rule;
+      }
+      function restoreCase(word, token) {
+        if (word === token) return token;
+        if (word === word.toLowerCase()) return token.toLowerCase();
+        if (word === word.toUpperCase()) return token.toUpperCase();
+        if (word[0] === word[0].toUpperCase()) {
+          return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+        }
+        return token.toLowerCase();
+      }
+      function interpolate(str, args) {
+        return str.replace(/\$(\d{1,2})/g, function(match, index) {
+          return args[index] || "";
+        });
+      }
+      function replace(word, rule) {
+        return word.replace(rule[0], function(match, index) {
+          var result = interpolate(rule[1], arguments);
+          if (match === "") {
+            return restoreCase(word[index - 1], result);
+          }
+          return restoreCase(match, result);
+        });
+      }
+      function sanitizeWord(token, word, rules) {
+        if (!token.length || uncountables.hasOwnProperty(token)) {
+          return word;
+        }
+        var len = rules.length;
+        while (len--) {
+          var rule = rules[len];
+          if (rule[0].test(word)) return replace(word, rule);
+        }
+        return word;
+      }
+      function replaceWord(replaceMap, keepMap, rules) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token)) {
+            return restoreCase(word, token);
+          }
+          if (replaceMap.hasOwnProperty(token)) {
+            return restoreCase(word, replaceMap[token]);
+          }
+          return sanitizeWord(token, word, rules);
+        };
+      }
+      function checkWord(replaceMap, keepMap, rules, bool) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token)) return true;
+          if (replaceMap.hasOwnProperty(token)) return false;
+          return sanitizeWord(token, token, rules) === token;
+        };
+      }
+      function pluralize2(word, count, inclusive) {
+        var pluralized = count === 1 ? pluralize2.singular(word) : pluralize2.plural(word);
+        return (inclusive ? count + " " : "") + pluralized;
+      }
+      pluralize2.plural = replaceWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize2.isPlural = checkWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize2.singular = replaceWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize2.isSingular = checkWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize2.addPluralRule = function(rule, replacement) {
+        pluralRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize2.addSingularRule = function(rule, replacement) {
+        singularRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize2.addUncountableRule = function(word) {
+        if (typeof word === "string") {
+          uncountables[word.toLowerCase()] = true;
+          return;
+        }
+        pluralize2.addPluralRule(word, "$0");
+        pluralize2.addSingularRule(word, "$0");
+      };
+      pluralize2.addIrregularRule = function(single, plural) {
+        plural = plural.toLowerCase();
+        single = single.toLowerCase();
+        irregularSingles[single] = plural;
+        irregularPlurals[plural] = single;
+      };
+      [
+        // Pronouns.
+        ["I", "we"],
+        ["me", "us"],
+        ["he", "they"],
+        ["she", "they"],
+        ["them", "them"],
+        ["myself", "ourselves"],
+        ["yourself", "yourselves"],
+        ["itself", "themselves"],
+        ["herself", "themselves"],
+        ["himself", "themselves"],
+        ["themself", "themselves"],
+        ["is", "are"],
+        ["was", "were"],
+        ["has", "have"],
+        ["this", "these"],
+        ["that", "those"],
+        // Words ending in with a consonant and `o`.
+        ["echo", "echoes"],
+        ["dingo", "dingoes"],
+        ["volcano", "volcanoes"],
+        ["tornado", "tornadoes"],
+        ["torpedo", "torpedoes"],
+        // Ends with `us`.
+        ["genus", "genera"],
+        ["viscus", "viscera"],
+        // Ends with `ma`.
+        ["stigma", "stigmata"],
+        ["stoma", "stomata"],
+        ["dogma", "dogmata"],
+        ["lemma", "lemmata"],
+        ["schema", "schemata"],
+        ["anathema", "anathemata"],
+        // Other irregular rules.
+        ["ox", "oxen"],
+        ["axe", "axes"],
+        ["die", "dice"],
+        ["yes", "yeses"],
+        ["foot", "feet"],
+        ["eave", "eaves"],
+        ["goose", "geese"],
+        ["tooth", "teeth"],
+        ["quiz", "quizzes"],
+        ["human", "humans"],
+        ["proof", "proofs"],
+        ["carve", "carves"],
+        ["valve", "valves"],
+        ["looey", "looies"],
+        ["thief", "thieves"],
+        ["groove", "grooves"],
+        ["pickaxe", "pickaxes"],
+        ["passerby", "passersby"]
+      ].forEach(function(rule) {
+        return pluralize2.addIrregularRule(rule[0], rule[1]);
+      });
+      [
+        [/s?$/i, "s"],
+        [/[^\u0000-\u007F]$/i, "$0"],
+        [/([^aeiou]ese)$/i, "$1"],
+        [/(ax|test)is$/i, "$1es"],
+        [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
+        [/(e[mn]u)s?$/i, "$1s"],
+        [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
+        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
+        [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
+        [/(seraph|cherub)(?:im)?$/i, "$1im"],
+        [/(her|at|gr)o$/i, "$1oes"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
+        [/sis$/i, "ses"],
+        [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
+        [/([^aeiouy]|qu)y$/i, "$1ies"],
+        [/([^ch][ieo][ln])ey$/i, "$1ies"],
+        [/(x|ch|ss|sh|zz)$/i, "$1es"],
+        [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
+        [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
+        [/(pe)(?:rson|ople)$/i, "$1ople"],
+        [/(child)(?:ren)?$/i, "$1ren"],
+        [/eaux$/i, "$0"],
+        [/m[ae]n$/i, "men"],
+        ["thou", "you"]
+      ].forEach(function(rule) {
+        return pluralize2.addPluralRule(rule[0], rule[1]);
+      });
+      [
+        [/s$/i, ""],
+        [/(ss)$/i, "$1"],
+        [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
+        [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
+        [/ies$/i, "y"],
+        [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
+        [/\b(mon|smil)ies$/i, "$1ey"],
+        [/\b((?:tit)?m|l)ice$/i, "$1ouse"],
+        [/(seraph|cherub)im$/i, "$1"],
+        [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"],
+        [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"],
+        [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
+        [/(test)(?:is|es)$/i, "$1is"],
+        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
+        [/(alumn|alg|vertebr)ae$/i, "$1a"],
+        [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
+        [/(matr|append)ices$/i, "$1ix"],
+        [/(pe)(rson|ople)$/i, "$1rson"],
+        [/(child)ren$/i, "$1"],
+        [/(eau)x?$/i, "$1"],
+        [/men$/i, "man"]
+      ].forEach(function(rule) {
+        return pluralize2.addSingularRule(rule[0], rule[1]);
+      });
+      [
+        // Singular words with no plurals.
+        "adulthood",
+        "advice",
+        "agenda",
+        "aid",
+        "aircraft",
+        "alcohol",
+        "ammo",
+        "analytics",
+        "anime",
+        "athletics",
+        "audio",
+        "bison",
+        "blood",
+        "bream",
+        "buffalo",
+        "butter",
+        "carp",
+        "cash",
+        "chassis",
+        "chess",
+        "clothing",
+        "cod",
+        "commerce",
+        "cooperation",
+        "corps",
+        "debris",
+        "diabetes",
+        "digestion",
+        "elk",
+        "energy",
+        "equipment",
+        "excretion",
+        "expertise",
+        "firmware",
+        "flounder",
+        "fun",
+        "gallows",
+        "garbage",
+        "graffiti",
+        "hardware",
+        "headquarters",
+        "health",
+        "herpes",
+        "highjinks",
+        "homework",
+        "housework",
+        "information",
+        "jeans",
+        "justice",
+        "kudos",
+        "labour",
+        "literature",
+        "machinery",
+        "mackerel",
+        "mail",
+        "media",
+        "mews",
+        "moose",
+        "music",
+        "mud",
+        "manga",
+        "news",
+        "only",
+        "personnel",
+        "pike",
+        "plankton",
+        "pliers",
+        "police",
+        "pollution",
+        "premises",
+        "rain",
+        "research",
+        "rice",
+        "salmon",
+        "scissors",
+        "series",
+        "sewage",
+        "shambles",
+        "shrimp",
+        "software",
+        "species",
+        "staff",
+        "swine",
+        "tennis",
+        "traffic",
+        "transportation",
+        "trout",
+        "tuna",
+        "wealth",
+        "welfare",
+        "whiting",
+        "wildebeest",
+        "wildlife",
+        "you",
+        /pok[eé]mon$/i,
+        // Regexes.
+        /[^aeiou]ese$/i,
+        // "chinese", "japanese"
+        /deer$/i,
+        // "deer", "reindeer"
+        /fish$/i,
+        // "fish", "blowfish", "angelfish"
+        /measles$/i,
+        /o[iu]s$/i,
+        // "carnivorous"
+        /pox$/i,
+        // "chickpox", "smallpox"
+        /sheep$/i
+      ].forEach(pluralize2.addUncountableRule);
+      return pluralize2;
+    });
+  })(pluralize$1);
+  return pluralize$1.exports;
+}
+var pluralizeExports = requirePluralize();
+const plur = /* @__PURE__ */ getDefaultExportFromCjs(pluralizeExports);
+plur.addPluralRule("glomerulus", "glomeruli");
+plur.addPluralRule("interstitium", "interstitia");
+function getNextScope(prevScopes) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const nextCharIndices = [0];
+  function next() {
+    const r = [];
+    nextCharIndices.forEach((charIndex) => {
+      r.unshift(chars[charIndex]);
+    });
+    let increment = true;
+    for (let i = 0; i < nextCharIndices.length; i++) {
+      const val = ++nextCharIndices[i];
+      if (val >= chars.length) {
+        nextCharIndices[i] = 0;
+      } else {
+        increment = false;
+        break;
+      }
+    }
+    if (increment) {
+      nextCharIndices.push(0);
+    }
+    return r.join("");
+  }
+  let nextScope;
+  do {
+    nextScope = next();
+  } while (prevScopes.includes(nextScope));
+  return nextScope;
+}
+function createPrefixedGetNextScopeNumeric(prefix) {
+  return (prevScopes) => {
+    let nextScopeInt = 0;
+    let nextScopeStr;
+    do {
+      nextScopeStr = `${prefix}${nextScopeInt}`;
+      nextScopeInt += 1;
+    } while (prevScopes.includes(nextScopeStr));
+    return nextScopeStr;
+  };
+}
+function getInitialCoordinationScopePrefix(datasetUid, dataType) {
+  return `init_${datasetUid}_${dataType}_`;
+}
+function getInitialCoordinationScopeName(datasetUid, dataType, i = null) {
+  const prefix = getInitialCoordinationScopePrefix(datasetUid, dataType);
+  return `${prefix}${i === null ? 0 : i}`;
+}
+var loglevel$1 = { exports: {} };
+var loglevel = loglevel$1.exports;
+var hasRequiredLoglevel;
+function requireLoglevel() {
+  if (hasRequiredLoglevel) return loglevel$1.exports;
+  hasRequiredLoglevel = 1;
+  (function(module2) {
+    (function(root, definition) {
+      if (module2.exports) {
+        module2.exports = definition();
+      } else {
+        root.log = definition();
+      }
+    })(loglevel, function() {
+      var noop = function() {
+      };
+      var undefinedType = "undefined";
+      var isIE = typeof window !== undefinedType && typeof window.navigator !== undefinedType && /Trident\/|MSIE /.test(window.navigator.userAgent);
+      var logMethods = [
+        "trace",
+        "debug",
+        "info",
+        "warn",
+        "error"
+      ];
+      var _loggersByName = {};
+      var defaultLogger = null;
+      function bindMethod(obj, methodName) {
+        var method = obj[methodName];
+        if (typeof method.bind === "function") {
+          return method.bind(obj);
+        } else {
+          try {
+            return Function.prototype.bind.call(method, obj);
+          } catch (e) {
+            return function() {
+              return Function.prototype.apply.apply(method, [obj, arguments]);
+            };
+          }
+        }
+      }
+      function traceForIE() {
+        if (console.log) {
+          if (console.log.apply) {
+            console.log.apply(console, arguments);
+          } else {
+            Function.prototype.apply.apply(console.log, [console, arguments]);
+          }
+        }
+        if (console.trace) console.trace();
+      }
+      function realMethod(methodName) {
+        if (methodName === "debug") {
+          methodName = "log";
+        }
+        if (typeof console === undefinedType) {
+          return false;
+        } else if (methodName === "trace" && isIE) {
+          return traceForIE;
+        } else if (console[methodName] !== void 0) {
+          return bindMethod(console, methodName);
+        } else if (console.log !== void 0) {
+          return bindMethod(console, "log");
+        } else {
+          return noop;
+        }
+      }
+      function replaceLoggingMethods() {
+        var level = this.getLevel();
+        for (var i = 0; i < logMethods.length; i++) {
+          var methodName = logMethods[i];
+          this[methodName] = i < level ? noop : this.methodFactory(methodName, level, this.name);
+        }
+        this.log = this.debug;
+        if (typeof console === undefinedType && level < this.levels.SILENT) {
+          return "No console available for logging";
+        }
+      }
+      function enableLoggingWhenConsoleArrives(methodName) {
+        return function() {
+          if (typeof console !== undefinedType) {
+            replaceLoggingMethods.call(this);
+            this[methodName].apply(this, arguments);
+          }
+        };
+      }
+      function defaultMethodFactory(methodName, _level, _loggerName) {
+        return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments);
+      }
+      function Logger(name, factory) {
+        var self = this;
+        var inheritedLevel;
+        var defaultLevel;
+        var userLevel;
+        var storageKey = "loglevel";
+        if (typeof name === "string") {
+          storageKey += ":" + name;
+        } else if (typeof name === "symbol") {
+          storageKey = void 0;
+        }
+        function persistLevelIfPossible(levelNum) {
+          var levelName = (logMethods[levelNum] || "silent").toUpperCase();
+          if (typeof window === undefinedType || !storageKey) return;
+          try {
+            window.localStorage[storageKey] = levelName;
+            return;
+          } catch (ignore) {
+          }
+          try {
+            window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";";
+          } catch (ignore) {
+          }
+        }
+        function getPersistedLevel() {
+          var storedLevel;
+          if (typeof window === undefinedType || !storageKey) return;
+          try {
+            storedLevel = window.localStorage[storageKey];
+          } catch (ignore) {
+          }
+          if (typeof storedLevel === undefinedType) {
+            try {
+              var cookie = window.document.cookie;
+              var cookieName = encodeURIComponent(storageKey);
+              var location = cookie.indexOf(cookieName + "=");
+              if (location !== -1) {
+                storedLevel = /^([^;]+)/.exec(
+                  cookie.slice(location + cookieName.length + 1)
+                )[1];
+              }
+            } catch (ignore) {
+            }
+          }
+          if (self.levels[storedLevel] === void 0) {
+            storedLevel = void 0;
+          }
+          return storedLevel;
+        }
+        function clearPersistedLevel() {
+          if (typeof window === undefinedType || !storageKey) return;
+          try {
+            window.localStorage.removeItem(storageKey);
+          } catch (ignore) {
+          }
+          try {
+            window.document.cookie = encodeURIComponent(storageKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+          } catch (ignore) {
+          }
+        }
+        function normalizeLevel(input) {
+          var level = input;
+          if (typeof level === "string" && self.levels[level.toUpperCase()] !== void 0) {
+            level = self.levels[level.toUpperCase()];
+          }
+          if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
+            return level;
+          } else {
+            throw new TypeError("log.setLevel() called with invalid level: " + input);
+          }
+        }
+        self.name = name;
+        self.levels = {
+          "TRACE": 0,
+          "DEBUG": 1,
+          "INFO": 2,
+          "WARN": 3,
+          "ERROR": 4,
+          "SILENT": 5
+        };
+        self.methodFactory = factory || defaultMethodFactory;
+        self.getLevel = function() {
+          if (userLevel != null) {
+            return userLevel;
+          } else if (defaultLevel != null) {
+            return defaultLevel;
+          } else {
+            return inheritedLevel;
+          }
+        };
+        self.setLevel = function(level, persist) {
+          userLevel = normalizeLevel(level);
+          if (persist !== false) {
+            persistLevelIfPossible(userLevel);
+          }
+          return replaceLoggingMethods.call(self);
+        };
+        self.setDefaultLevel = function(level) {
+          defaultLevel = normalizeLevel(level);
+          if (!getPersistedLevel()) {
+            self.setLevel(level, false);
+          }
+        };
+        self.resetLevel = function() {
+          userLevel = null;
+          clearPersistedLevel();
+          replaceLoggingMethods.call(self);
+        };
+        self.enableAll = function(persist) {
+          self.setLevel(self.levels.TRACE, persist);
+        };
+        self.disableAll = function(persist) {
+          self.setLevel(self.levels.SILENT, persist);
+        };
+        self.rebuild = function() {
+          if (defaultLogger !== self) {
+            inheritedLevel = normalizeLevel(defaultLogger.getLevel());
+          }
+          replaceLoggingMethods.call(self);
+          if (defaultLogger === self) {
+            for (var childName in _loggersByName) {
+              _loggersByName[childName].rebuild();
+            }
+          }
+        };
+        inheritedLevel = normalizeLevel(
+          defaultLogger ? defaultLogger.getLevel() : "WARN"
+        );
+        var initialLevel = getPersistedLevel();
+        if (initialLevel != null) {
+          userLevel = normalizeLevel(initialLevel);
+        }
+        replaceLoggingMethods.call(self);
+      }
+      defaultLogger = new Logger();
+      defaultLogger.getLogger = function getLogger(name) {
+        if (typeof name !== "symbol" && typeof name !== "string" || name === "") {
+          throw new TypeError("You must supply a name when creating a logger.");
+        }
+        var logger = _loggersByName[name];
+        if (!logger) {
+          logger = _loggersByName[name] = new Logger(
+            name,
+            defaultLogger.methodFactory
+          );
+        }
+        return logger;
+      };
+      var _log = typeof window !== undefinedType ? window.log : void 0;
+      defaultLogger.noConflict = function() {
+        if (typeof window !== undefinedType && window.log === defaultLogger) {
+          window.log = _log;
+        }
+        return defaultLogger;
+      };
+      defaultLogger.getLoggers = function getLoggers() {
+        return _loggersByName;
+      };
+      defaultLogger["default"] = defaultLogger;
+      return defaultLogger;
+    });
+  })(loglevel$1);
+  return loglevel$1.exports;
+}
+var loglevelExports = requireLoglevel();
+const log = /* @__PURE__ */ getDefaultExportFromCjs(loglevelExports);
+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, requestInit) {
+    this.file = {
+      url,
+      fileType,
+      ...coordinationValues ? { coordinationValues } : {},
+      ...options ? { options } : {},
+      ...requestInit ? { requestInit } : {}
+    };
+  }
+  /**
+   * @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;
+    let requestInit;
+    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,
+        requestInit
+      } = params);
+    } else {
+      throw new Error("Expected addFile argument to be an object.");
+    }
+    this.dataset.files.push(
+      new VitessceConfigDatasetFile(url, fileType, coordinationValues, options, requestInit)
+    );
+    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) {
+    if (Array.isArray(levelVal)) {
+      coordinationScopesBy[parentType] = {
+        ...coordinationScopesBy[parentType] || {},
+        [levelType]: {
+          ...coordinationScopesBy[parentType]?.[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]: {
+          ...coordinationScopesBy[parentType]?.[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, uid) {
+    this.view = {
+      component,
+      coordinationScopes,
+      coordinationScopesBy: void 0,
+      // TODO: initialize from parameter?
+      x,
+      y,
+      w,
+      h,
+      uid
+    };
+  }
+  /**
+   * 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.META_COORDINATION_SCOPES] = [
+      ...this.view.coordinationScopes[CoordinationType.META_COORDINATION_SCOPES] || [],
+      metaScope.metaScope.cScope
+    ];
+    this.view.coordinationScopes[CoordinationType.META_COORDINATION_SCOPES_BY] = [
+      ...this.view.coordinationScopes[CoordinationType.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;
+  }
+}
+function hconcat(...views) {
+  const vcvhc = new VitessceConfigViewHConcat(views);
+  return vcvhc;
+}
+function vconcat(...views) {
+  const vcvvc = new VitessceConfigViewVConcat(views);
+  return vcvvc;
+}
+class CoordinationLevel {
+  constructor(value) {
+    this.value = value;
+    this.cachedValue = null;
+  }
+  setCached(processedLevel) {
+    this.cachedValue = processedLevel;
+  }
+  getCached() {
+    return this.cachedValue;
+  }
+  isCached() {
+    return this.cachedValue !== null;
+  }
+}
+function CL(value) {
+  return new CoordinationLevel(value);
+}
+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.META_COORDINATION_SCOPES,
+      metaScope
+    );
+    this.metaByScope = new VitessceConfigCoordinationScope(
+      CoordinationType.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.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|undefined} options Extra options for the component.
+   * @param {number|undefined} options.x The x-coordinate for the view
+   * in the grid layout.
+   * @param {number|undefined} options.y The y-coordinate for the view
+   * in the grid layout.
+   * @param {number|undefined} options.w The width for the view in the
+   * grid layout.
+   * @param {number|undefined} options.h The height for the view in the
+   * grid layout.
+   * @param {string|undefined} 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,
+      uid = void 0,
+      mapping = null
+    } = options || {};
+    const datasetMatches = this.config.coordinationSpace[CoordinationType.DATASET] ? Object.entries(this.config.coordinationSpace[CoordinationType.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.DATASET]: datasetScope
+    };
+    const newView = new VitessceConfigView(component, coordinationScopes, x, y, w, h, uid);
+    if (mapping) {
+      const [etScope] = this.addCoordination(CoordinationType.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((cTypeOrObj) => {
+      let cType;
+      let cScope;
+      let cValue;
+      if (typeof cTypeOrObj === "string") {
+        cType = cTypeOrObj;
+        const prevScopes = this.config.coordinationSpace[cType] ? Object.keys(this.config.coordinationSpace[cType]) : [];
+        cScope = this.getNextScope(prevScopes);
+      } else {
+        cType = cTypeOrObj.cType;
+        cScope = cTypeOrObj.cScope;
+        cValue = cTypeOrObj.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;
+      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.META_COORDINATION_SCOPES] ? Object.keys(this.config.coordinationSpace[CoordinationType.META_COORDINATION_SCOPES]) : [];
+    const prevMetaByScopes = this.config.coordinationSpace[CoordinationType.META_COORDINATION_SCOPES_BY] ? Object.keys(this.config.coordinationSpace[CoordinationType.META_COORDINATION_SCOPES_BY]) : [];
+    const metaContainer = new VitessceConfigMetaCoordinationScope(
+      this.getNextScope(prevMetaScopes),
+      this.getNextScope(prevMetaByScopes)
+    );
+    if (!this.config.coordinationSpace[CoordinationType.META_COORDINATION_SCOPES]) {
+      this.config.coordinationSpace[CoordinationType.META_COORDINATION_SCOPES] = {};
+    }
+    if (!this.config.coordinationSpace[CoordinationType.META_COORDINATION_SCOPES_BY]) {
+      this.config.coordinationSpace[CoordinationType.META_COORDINATION_SCOPES_BY] = {};
+    }
+    this.config.coordinationSpace[CoordinationType.META_COORDINATION_SCOPES][metaContainer.metaScope.cScope] = metaContainer.metaScope;
+    this.config.coordinationSpace[CoordinationType.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: Object.fromEntries(
+        Object.entries(this.config.coordinationSpace).map(([cType, cScopes]) => [
+          cType,
+          Object.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.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,
+        c.uid
+      );
+      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
+  };
+}
+const SINGLE_CELL_WITH_HEATMAP_VIEWS = {
+  obsSets: { x: 4, y: 0, w: 4, h: 4 },
+  obsSetSizes: { x: 8, y: 0, w: 4, h: 4 },
+  scatterplot: { x: 0, y: 0, w: 4, h: 4 },
+  heatmap: { x: 0, y: 4, w: 8, h: 4 },
+  featureList: { x: 8, y: 4, w: 4, h: 4 }
+};
+const SINGLE_CELL_WITHOUT_HEATMAP_VIEWS = {
+  obsSets: { x: 10, y: 6, w: 2, h: 6 },
+  obsSetSizes: { x: 8, y: 1, w: 4, h: 6 },
+  scatterplot: { x: 0, y: 0, w: 8, h: 12 },
+  featureList: { x: 8, y: 6, w: 2, h: 6 }
+};
+const SPATIAL_TRANSCRIPTOMICS_VIEWS = {
+  scatterplot: { x: 0, y: 0, w: 3, h: 4 },
+  spatial: { x: 3, y: 0, w: 5, h: 4 },
+  obsSets: { x: 8, y: 0, w: 4, h: 2 },
+  featureList: { x: 8, y: 0, w: 4, h: 2 },
+  heatmap: { x: 0, y: 4, w: 6, h: 4 },
+  obsSetFeatureValueDistribution: { x: 6, y: 4, w: 6, h: 4 }
+};
+const SPATIAL_TRANSCRIPTOMICS_WITH_HSITOLOGY_VIEWS = {
+  spatial: { x: 0, y: 0, w: 6, h: 6 },
+  heatmap: { x: 0, y: 6, w: 8, h: 6 },
+  layerController: { x: 8, y: 6, w: 4, h: 6 },
+  obsSets: { x: 9, y: 0, w: 3, h: 6 },
+  featureList: { x: 6, y: 0, w: 3, h: 6 }
+};
+const IMAGE_VIEWS = {
+  spatial: { x: 0, y: 0, w: 8, h: 12 },
+  layerController: { x: 8, y: 0, w: 4, h: 7 },
+  description: { x: 8, y: 9, w: 4, h: 5 }
+};
+const NO_HINTS_CONFIG = {
+  views: {},
+  coordinationValues: {}
+};
+const HINTS_CONFIG = {
+  "No hints are available. Generate config with no hints.": NO_HINTS_CONFIG,
+  Basic: NO_HINTS_CONFIG,
+  "Transcriptomics / scRNA-seq (with heatmap)": {
+    views: SINGLE_CELL_WITH_HEATMAP_VIEWS
+  },
+  "Transcriptomics / scRNA-seq (without heatmap)": {
+    views: SINGLE_CELL_WITHOUT_HEATMAP_VIEWS
+  },
+  "Spatial transcriptomics (with polygon cell segmentations)": {
+    views: SPATIAL_TRANSCRIPTOMICS_VIEWS
+  },
+  "Chromatin accessibility / scATAC-seq (with heatmap)": {
+    views: SINGLE_CELL_WITH_HEATMAP_VIEWS,
+    coordinationValues: {
+      featureType: "peak"
+    }
+  },
+  "Chromatin accessibility / scATAC-seq (without heatmap)": {
+    views: SINGLE_CELL_WITHOUT_HEATMAP_VIEWS,
+    coordinationValues: {
+      featureType: "peak"
+    }
+  },
+  "Spatial transcriptomics (with histology image and polygon cell segmentations)": {
+    views: SPATIAL_TRANSCRIPTOMICS_WITH_HSITOLOGY_VIEWS,
+    coordinationSpaceRequired: true
+  },
+  Image: {
+    views: IMAGE_VIEWS
+  }
+};
+const HINT_TYPE_TO_FILE_TYPE_MAP = {
+  "AnnData-Zarr": [
+    "Basic",
+    "Transcriptomics / scRNA-seq (with heatmap)",
+    "Transcriptomics / scRNA-seq (without heatmap)",
+    "Spatial transcriptomics (with polygon cell segmentations)",
+    "Chromatin accessibility / scATAC-seq (with heatmap)",
+    "Chromatin accessibility / scATAC-seq (without heatmap)"
+  ],
+  "OME-TIFF": [
+    "Basic",
+    "Image"
+  ],
+  "AnnData-Zarr,OME-TIFF": [
+    "Basic",
+    "Spatial transcriptomics (with histology image and polygon cell segmentations)"
+  ]
+};
+const filterViews = (hintsConfig, possibleViews) => {
+  const requiredViews = Object.keys(hintsConfig.views);
+  if (requiredViews.length === 0) {
+    return possibleViews;
+  }
+  const resultViews = [];
+  requiredViews.forEach((requiredView) => {
+    const match = possibleViews.find((possibleView) => possibleView[0] === requiredView);
+    if (match) resultViews.push(match);
+  });
+  if (resultViews.length === 0) {
+    throw new Error("No views found that are compatible with the supplied dataset URLs and hint.");
+  }
+  return resultViews;
+};
+let AbstractAutoConfig$1 = class AbstractAutoConfig {
+  async composeViewsConfig() {
+    throw new Error("The composeViewsConfig() method has not been implemented.");
+  }
+  async composeFileConfig() {
+    throw new Error("The composeFileConfig() method has not been implemented.");
+  }
+};
+class OmeTiffAutoConfig extends AbstractAutoConfig$1 {
+  constructor(fileUrl) {
+    super();
+    this.fileUrl = fileUrl;
+    this.fileType = FileType.RASTER_JSON;
+    this.fileName = fileUrl.split("/").at(-1);
+  }
+  async composeViewsConfig(hintsConfig) {
+    return filterViews(
+      hintsConfig,
+      [["description"], ["spatial"], ["layerController"]]
+    );
+  }
+  async composeFileConfig() {
+    return {
+      fileType: this.fileType,
+      options: {
+        images: [
+          {
+            metadata: {
+              isBitmask: false
+            },
+            name: this.fileName,
+            type: "ome-tiff",
+            url: this.fileUrl
+          }
+        ],
+        schemaVersion: "0.0.2",
+        usePhysicalSizeScaling: false
+      }
+    };
+  }
+}
+class OmeZarrAutoConfig extends AbstractAutoConfig$1 {
+  constructor(fileUrl) {
+    super();
+    this.fileUrl = fileUrl;
+    this.fileType = FileType.RASTER_OME_ZARR;
+    this.fileName = fileUrl.split("/").at(-1);
+  }
+  async composeViewsConfig(hintsConfig) {
+    return filterViews(
+      hintsConfig,
+      [["description"], ["spatial"], ["layerController"]]
+    );
+  }
+  async composeFileConfig() {
+    return {
+      fileType: this.fileType,
+      type: "raster",
+      url: this.fileUrl
+    };
+  }
+}
+class AnndataZarrAutoConfig extends AbstractAutoConfig$1 {
+  constructor(fileUrl) {
+    super();
+    this.fileUrl = fileUrl;
+    this.fileType = FileType.ANNDATA_ZARR;
+    this.fileName = fileUrl.split("/").at(-1);
+    this.metadataSummary = {};
+  }
+  async composeFileConfig() {
+    this.metadataSummary = await this.setMetadataSummary();
+    const options = {
+      obsEmbedding: [],
+      obsFeatureMatrix: {
+        path: "X"
+      }
+    };
+    this.metadataSummary.obsm.forEach((key) => {
+      if (key.toLowerCase().includes("obsm/x_segmentations")) {
+        options.obsSegmentations = { path: key };
+      }
+      if (key.toLowerCase().includes("obsm/x_spatial")) {
+        options.obsLocations = { path: key };
+      }
+      if (key.toLowerCase().includes("obsm/x_umap")) {
+        options.obsEmbedding.push({ path: key, embeddingType: "UMAP" });
+      }
+      if (key.toLowerCase().includes("obsm/x_tsne")) {
+        options.obsEmbedding.push({ path: key, embeddingType: "t-SNE" });
+      }
+      if (key.toLowerCase().includes("obsm/x_pca")) {
+        options.obsEmbedding.push({ path: key, embeddingType: "PCA" });
+      }
+    });
+    const supportedObsSetsKeys = [
+      "cluster",
+      "clusters",
+      "subcluster",
+      "cell_type",
+      "celltype",
+      "leiden",
+      "louvain",
+      "disease",
+      "organism",
+      "self_reported_ethnicity",
+      "tissue",
+      "sex"
+    ];
+    this.metadataSummary.obs.forEach((key) => {
+      supportedObsSetsKeys.forEach((supportedKey) => {
+        if (key.toLowerCase() === ["obs", supportedKey].join("/")) {
+          if (!("obsSets" in options)) {
+            options.obsSets = [
+              {
+                name: "Cell Type",
+                path: [key]
+              }
+            ];
+          } else {
+            options.obsSets[0].path.push(key);
+          }
+        }
+      });
+    });
+    options.obsSets = options.obsSets?.map((obsSet) => {
+      if (obsSet.path.length === 1) {
+        return {
+          ...obsSet,
+          path: obsSet.path[0]
+        };
+      }
+      return obsSet;
+    });
+    return {
+      options,
+      fileType: this.fileType,
+      url: this.fileUrl,
+      coordinationValues: {
+        obsType: "cell",
+        featureType: "gene",
+        featureValueType: "expression"
+      }
+    };
+  }
+  async composeViewsConfig(hintsConfig) {
+    this.metadataSummary = await this.setMetadataSummary();
+    const possibleViews = [];
+    const hasCellSetData = this.metadataSummary.obs.filter((key) => key.toLowerCase().includes("cluster") || key.toLowerCase().includes("cell_type") || key.toLowerCase().includes("celltype"));
+    if (hasCellSetData.length > 0) {
+      possibleViews.push(["obsSets"]);
+    }
+    this.metadataSummary.obsm.forEach((key) => {
+      if (key.toLowerCase().includes("obsm/x_umap")) {
+        possibleViews.push(["scatterplot", { mapping: "UMAP" }]);
+      }
+      if (key.toLowerCase().includes("obsm/x_tsne")) {
+        possibleViews.push(["scatterplot", { mapping: "t-SNE" }]);
+      }
+      if (key.toLowerCase().includes("obsm/x_pca")) {
+        possibleViews.push(["scatterplot", { mapping: "PCA" }]);
+      }
+      if (key.toLowerCase().includes("obsm/x_segmentations")) {
+        possibleViews.push(["layerController"]);
+      }
+      if (key.toLowerCase().includes("obsm/x_spatial")) {
+        possibleViews.push(["spatial"]);
+      }
+    });
+    possibleViews.push(["obsSetSizes"]);
+    possibleViews.push(["obsSetFeatureValueDistribution"]);
+    if (this.metadataSummary.X) {
+      possibleViews.push(["heatmap"]);
+      possibleViews.push(["featureList"]);
+    }
+    const views = filterViews(hintsConfig, possibleViews);
+    return views;
+  }
+  async setMetadataSummaryWithZmetadata(response) {
+    const metadataFile = await response.json();
+    if (!metadataFile.metadata) {
+      throw new Error("Could not generate config: .zmetadata file is not valid.");
+    }
+    const obsmKeys = Object.keys(metadataFile.metadata).filter((key) => key.startsWith("obsm/X_")).map((key) => key.split("/.zarray")[0]);
+    const obsKeysArr = Object.keys(metadataFile.metadata).filter((key) => key.startsWith("obs/")).map((key) => key.split("/.za")[0]);
+    function uniq(a) {
+      return a.sort().filter((item, pos, ary) => !pos || item !== ary[pos - 1]);
+    }
+    const obsKeys = uniq(obsKeysArr);
+    const X = Object.keys(metadataFile.metadata).filter((key) => key.startsWith("X"));
+    return {
+      // Array of keys in obsm that are found by the fetches above
+      obsm: obsmKeys,
+      // Array of keys in obs that are found by the fetches above
+      obs: obsKeys,
+      // Boolean indicating whether the X array was found by the fetches above
+      X: X.length > 0
+    };
+  }
+  async setMetadataSummaryWithoutZmetadata() {
+    const knownMetadataFileSuffixes = [
+      "/obsm/X_pca/.zarray",
+      "/obsm/X_umap/.zarray",
+      "/obsm/X_tsne/.zarray",
+      "/obsm/X_spatial/.zarray",
+      "/obsm/X_segmentations/.zarray",
+      "/obs/.zattrs",
+      "/X/.zarray",
+      "/X/data/.zarray"
+      // for https://data-1.vitessce.io/0.0.33/main/human-lymph-node-10x-visium/human_lymph_node_10x_visium.h5ad.zarr
+    ];
+    const getObsmKey = (url) => {
+      const obsmKeyStartIndex = `${this.fileUrl}/`.length;
+      const obsmKeyEndIndex = url.length - "/.zarray".length;
+      return url.substring(obsmKeyStartIndex, obsmKeyEndIndex);
+    };
+    const promises = knownMetadataFileSuffixes.map((suffix) => fetch(`${this.fileUrl}${suffix}`));
+    const fetchResults = await Promise.all(promises);
+    const okFetchResults = fetchResults.filter((j) => j.ok);
+    const metadataSummary = {
+      // Array of keys in obsm that are found by the fetches above
+      obsm: [],
+      // Array of keys in obs that are found by the fetches above
+      obs: [],
+      // Boolean indicating whether the X array was found by the fetches above
+      X: false
+    };
+    const obsPromiseResult = okFetchResults.find(
+      (r) => r.url === `${this.fileUrl}/obs/.zattrs`
+    );
+    const isObsValid = (obsAttr) => Object.keys(obsAttr).includes("column-order") && Object.keys(obsAttr).includes("encoding-version") && Object.keys(obsAttr).includes("encoding-type") && obsAttr["encoding-type"] === "dataframe" && (obsAttr["encoding-version"] === "0.1.0" || obsAttr["encoding-version"] === "0.2.0");
+    if (obsPromiseResult) {
+      const obsAttrs = await obsPromiseResult.json();
+      if (isObsValid(obsAttrs)) {
+        obsAttrs["column-order"].forEach((key) => metadataSummary.obs.push(`obs/${key}`));
+      } else {
+        throw new Error("Could not generate config: /obs/.zattrs file is not valid.");
+      }
+    }
+    okFetchResults.forEach((r) => {
+      if (r.url.startsWith(`${this.fileUrl}/obsm`)) {
+        const obsmKey = getObsmKey(r.url);
+        if (obsmKey) {
+          metadataSummary.obsm.push(obsmKey);
+        }
+      } else if (r.url.startsWith(`${this.fileUrl}/X`)) {
+        metadataSummary.X = true;
+      }
+    });
+    return metadataSummary;
+  }
+  async setMetadataSummary() {
+    if (Object.keys(this.metadataSummary).length > 0) {
+      return this.metadataSummary;
+    }
+    const metadataExtension = ".zmetadata";
+    const url = [this.fileUrl, metadataExtension].join("/");
+    return fetch(url).then((response) => {
+      if (response.ok) {
+        return this.setMetadataSummaryWithZmetadata(response);
+      }
+      if (response.status === 404) {
+        return this.setMetadataSummaryWithoutZmetadata();
+      }
+      throw new Error(`Could not generate config: ${response.statusText}`);
+    }).catch((error) => {
+      throw new Error(`Could not generate config for URL ${this.fileUrl}: ${error}`);
+    });
+  }
+}
+const configClasses = [
+  {
+    extensions: [".ome.tif", ".ome.tiff", ".ome.tf2", ".ome.tf8"],
+    class: OmeTiffAutoConfig,
+    name: "OME-TIFF"
+  },
+  {
+    extensions: [".h5ad.zarr", ".adata.zarr", ".anndata.zarr"],
+    class: AnndataZarrAutoConfig,
+    name: "AnnData-Zarr"
+  },
+  {
+    extensions: ["ome.zarr"],
+    class: OmeZarrAutoConfig,
+    name: "OME-Zarr"
+  }
+];
+function calculateCoordinates(viewsNumb) {
+  const rows = Math.ceil(Math.sqrt(viewsNumb));
+  const cols = Math.ceil(viewsNumb / rows);
+  const width = 12 / cols;
+  const height = 12 / rows;
+  const coords = [];
+  for (let i = 0; i < viewsNumb; i++) {
+    const row = Math.floor(i / cols);
+    const col = i % cols;
+    const x = col * width;
+    const y = row * height;
+    coords.push([
+      Math.floor(x),
+      Math.floor(y),
+      // Ensure width/height is at least 1.
+      Math.max(1, Math.floor(width)),
+      Math.max(1, Math.floor(height))
+    ]);
+  }
+  return coords;
+}
+const spatialSegmentationLayerValue = {
+  radius: 65,
+  stroked: true,
+  visible: true,
+  opacity: 1
+};
+function insertCoordinationSpaceForSpatial(views, vc) {
+  const [
+    spatialSegmentationLayer,
+    spatialImageLayer,
+    spatialZoom,
+    spatialTargetX,
+    spatialTargetY
+  ] = vc.addCoordination(
+    CoordinationType.SPATIAL_SEGMENTATION_LAYER,
+    CoordinationType.SPATIAL_IMAGE_LAYER,
+    CoordinationType.SPATIAL_ZOOM,
+    CoordinationType.SPATIAL_TARGET_X,
+    CoordinationType.SPATIAL_TARGET_Y
+  );
+  spatialSegmentationLayer.setValue(spatialSegmentationLayerValue);
+  spatialImageLayer.setValue([
+    {
+      type: "raster",
+      index: 0,
+      colormap: null,
+      transparentColor: null,
+      opacity: 1,
+      domainType: "Min/Max",
+      channels: [
+        {
+          selection: {
+            c: 0
+          },
+          color: [
+            255,
+            0,
+            0
+          ],
+          visible: true,
+          slider: [
+            0,
+            255
+          ]
+        },
+        {
+          selection: {
+            c: 1
+          },
+          color: [
+            0,
+            255,
+            0
+          ],
+          visible: true,
+          slider: [
+            0,
+            255
+          ]
+        },
+        {
+          selection: {
+            c: 2
+          },
+          color: [
+            0,
+            0,
+            255
+          ],
+          visible: true,
+          slider: [
+            0,
+            255
+          ]
+        }
+      ]
+    }
+  ]);
+  views.forEach((view) => {
+    if (view.view.component === "spatial" || view.view.component === "layerController") {
+      view.useCoordination(spatialImageLayer);
+      view.useCoordination(spatialSegmentationLayer);
+      view.useCoordination(spatialZoom);
+      view.useCoordination(spatialTargetX);
+      view.useCoordination(spatialTargetY);
+    }
+  });
+}
+function getFileType(url) {
+  const match = configClasses.find((obj) => obj.extensions.filter(
+    (ext) => url.endsWith(ext)
+  ).length === 1);
+  if (!match) {
+    throw new Error("One or more of the URLs provided point to unsupported file types.");
+  }
+  return match;
+}
+async function generateViewDefinition(url, vc, dataset, hintsConfig) {
+  let ConfigClassName;
+  try {
+    ConfigClassName = getFileType(url).class;
+  } catch (err) {
+    return Promise.reject(err);
+  }
+  const configInstance = new ConfigClassName(url);
+  let fileConfig;
+  let viewsConfig;
+  try {
+    fileConfig = await configInstance.composeFileConfig();
+    viewsConfig = await configInstance.composeViewsConfig(hintsConfig);
+  } catch (error) {
+    log.error(error);
+    return Promise.reject(error);
+  }
+  dataset.addFile(fileConfig);
+  let layerControllerView = false;
+  let spatialView = false;
+  const views = [];
+  viewsConfig.forEach((v) => {
+    const view = vc.addView(dataset, ...v);
+    if (v[0] === "layerController") {
+      layerControllerView = view;
+    }
+    if (v[0] === "spatial") {
+      spatialView = view;
+    }
+    if (v[0] === "layerController") {
+      view.setProps({
+        disable3d: [],
+        disableChannelsIfRgbDetected: true
+      });
+    }
+    if (v[0] === "heatmap" && configInstance instanceof AnndataZarrAutoConfig) {
+      view.setProps({ transpose: true });
+    }
+    views.push(view);
+  });
+  if (layerControllerView && spatialView && configInstance instanceof AnndataZarrAutoConfig) {
+    vc.linkViews(
+      [spatialView, layerControllerView],
+      [
+        CoordinationType.SPATIAL_SEGMENTATION_LAYER
+      ],
+      [spatialSegmentationLayerValue]
+    );
+  }
+  return views;
+}
+function getHintOptions(fileUrls) {
+  const fileTypes = {};
+  fileUrls.forEach((url) => {
+    const match = getFileType(url);
+    if (match.name === "OME-Zarr") {
+      fileTypes["OME-TIFF"] = true;
+    } else {
+      fileTypes[match.name] = true;
+    }
+  });
+  const datasetType = Object.keys(fileTypes).sort().join(",");
+  return HINT_TYPE_TO_FILE_TYPE_MAP?.[datasetType] || [];
+}
+async function generateConfig$1(fileUrls, hintTitle = null) {
+  const vc = new VitessceConfig({
+    schemaVersion: "1.0.15",
+    name: "An automatically generated config. Adjust values and add layout components if needed.",
+    description: "Populate with text relevant to this visualisation."
+  });
+  const allViews = [];
+  const dataset = vc.addDataset("An automatically generated view config for dataset. Adjust values and add layout components if needed.");
+  const hintsConfig = !hintTitle ? { views: {} } : HINTS_CONFIG?.[hintTitle];
+  if (!hintsConfig) {
+    throw new Error(`Hints config not found for the supplied hint: ${hintTitle}.`);
+  }
+  const useHints = Object.keys(hintsConfig?.views)?.length > 0;
+  fileUrls.forEach((url) => {
+    allViews.push(generateViewDefinition(url, vc, dataset, hintsConfig));
+  });
+  return Promise.all(allViews).then((views) => {
+    const flattenedViews = views.flat();
+    if (hintsConfig?.coordinationSpaceRequired) {
+      insertCoordinationSpaceForSpatial(flattenedViews, vc);
+    }
+    if (!useHints) {
+      const coord = calculateCoordinates(flattenedViews.length);
+      for (let i = 0; i < flattenedViews.length; i++) {
+        flattenedViews[i].setXYWH(...coord[i]);
+      }
+    } else {
+      flattenedViews.forEach((vitessceConfigView) => {
+        const coordinates = Object.values(hintsConfig.views[vitessceConfigView.view.component]);
+        vitessceConfigView.setXYWH(...coordinates);
+      });
+    }
+    return vc.toJSON();
+  });
+}
+function strip_prefix(path) {
+  return path.slice(1);
+}
+function fetch_range(url, offset, length, opts = {}) {
+  if (offset !== void 0 && length !== void 0) {
+    opts = {
+      ...opts,
+      headers: {
+        ...opts.headers,
+        Range: `bytes=${offset}-${offset + length - 1}`
+      }
+    };
+  }
+  return fetch(url, opts);
+}
+function merge_init(storeOverrides, requestOverrides) {
+  return {
+    ...storeOverrides,
+    ...requestOverrides,
+    headers: {
+      ...storeOverrides.headers,
+      ...requestOverrides.headers
+    }
+  };
+}
+function assert$1(expression, msg = "") {
+  if (!expression)
+    throw new Error(msg);
+}
+function resolve(root, path) {
+  const base = typeof root === "string" ? new URL(root) : root;
+  if (!base.pathname.endsWith("/")) {
+    base.pathname += "/";
+  }
+  const resolved = new URL(path.slice(1), base);
+  resolved.search = base.search;
+  return resolved;
+}
+async function handle_response(response) {
+  if (response.status === 404) {
+    return void 0;
+  }
+  if (response.status === 200 || response.status === 206) {
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  throw new Error(`Unexpected response status ${response.status} ${response.statusText}`);
+}
+async function fetch_suffix(url, suffix_length, init, use_suffix_request) {
+  if (use_suffix_request) {
+    return fetch(url, {
+      ...init,
+      headers: { ...init.headers, Range: `bytes=-${suffix_length}` }
+    });
+  }
+  let response = await fetch(url, { ...init, method: "HEAD" });
+  if (!response.ok) {
+    return response;
+  }
+  let content_length = response.headers.get("Content-Length");
+  let length = Number(content_length);
+  return fetch_range(url, length - suffix_length, length, init);
+}
+class FetchStore {
+  #overrides;
+  #use_suffix_request;
+  constructor(url, options = {}) {
+    this.url = url;
+    this.#overrides = options.overrides ?? {};
+    this.#use_suffix_request = options.useSuffixRequest ?? false;
+  }
+  #merge_init(overrides) {
+    return merge_init(this.#overrides, overrides);
+  }
+  async get(key, options = {}) {
+    let href = resolve(this.url, key).href;
+    let response = await fetch(href, this.#merge_init(options));
+    return handle_response(response);
+  }
+  async getRange(key, range, options = {}) {
+    let url = resolve(this.url, key);
+    let init = this.#merge_init(options);
+    let response;
+    if ("suffixLength" in range) {
+      response = await fetch_suffix(url, range.suffixLength, init, this.#use_suffix_request);
+    } else {
+      response = await fetch_range(url, range.offset, range.length, init);
+    }
+    return handle_response(response);
+  }
+}
+class BoolArray {
+  #bytes;
+  constructor(x, byteOffset, length) {
+    if (typeof x === "number") {
+      this.#bytes = new Uint8Array(x);
+    } else if (x instanceof ArrayBuffer) {
+      this.#bytes = new Uint8Array(x, byteOffset, length);
+    } else {
+      this.#bytes = new Uint8Array(Array.from(x, (v) => v ? 1 : 0));
+    }
+  }
+  get BYTES_PER_ELEMENT() {
+    return 1;
+  }
+  get byteOffset() {
+    return this.#bytes.byteOffset;
+  }
+  get byteLength() {
+    return this.#bytes.byteLength;
+  }
+  get buffer() {
+    return this.#bytes.buffer;
+  }
+  get length() {
+    return this.#bytes.length;
+  }
+  get(idx) {
+    let value = this.#bytes[idx];
+    return typeof value === "number" ? value !== 0 : value;
+  }
+  set(idx, value) {
+    this.#bytes[idx] = value ? 1 : 0;
+  }
+  fill(value) {
+    this.#bytes.fill(value ? 1 : 0);
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.length; i++) {
+      yield this.get(i);
+    }
+  }
+}
+class ByteStringArray {
+  #encoder;
+  constructor(chars, x, byteOffset, length) {
+    this.chars = chars;
+    this.#encoder = new TextEncoder();
+    if (typeof x === "number") {
+      this._data = new Uint8Array(x * chars);
+    } else if (x instanceof ArrayBuffer) {
+      if (length)
+        length = length * chars;
+      this._data = new Uint8Array(x, byteOffset, length);
+    } else {
+      let values = Array.from(x);
+      this._data = new Uint8Array(values.length * chars);
+      for (let i = 0; i < values.length; i++) {
+        this.set(i, values[i]);
+      }
+    }
+  }
+  get BYTES_PER_ELEMENT() {
+    return this.chars;
+  }
+  get byteOffset() {
+    return this._data.byteOffset;
+  }
+  get byteLength() {
+    return this._data.byteLength;
+  }
+  get buffer() {
+    return this._data.buffer;
+  }
+  get length() {
+    return this.byteLength / this.BYTES_PER_ELEMENT;
+  }
+  get(idx) {
+    const view = new Uint8Array(this.buffer, this.byteOffset + this.chars * idx, this.chars);
+    return new TextDecoder().decode(view).replace(/\x00/g, "");
+  }
+  set(idx, value) {
+    const view = new Uint8Array(this.buffer, this.byteOffset + this.chars * idx, this.chars);
+    view.fill(0);
+    view.set(this.#encoder.encode(value));
+  }
+  fill(value) {
+    const encoded = this.#encoder.encode(value);
+    for (let i = 0; i < this.length; i++) {
+      this._data.set(encoded, i * this.chars);
+    }
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.length; i++) {
+      yield this.get(i);
+    }
+  }
+}
+class UnicodeStringArray {
+  #data;
+  constructor(chars, x, byteOffset, length) {
+    this.chars = chars;
+    if (typeof x === "number") {
+      this.#data = new Int32Array(x * chars);
+    } else if (x instanceof ArrayBuffer) {
+      if (length)
+        length *= chars;
+      this.#data = new Int32Array(x, byteOffset, length);
+    } else {
+      const values = x;
+      const d = new UnicodeStringArray(chars, 1);
+      this.#data = new Int32Array(function* () {
+        for (let str of values) {
+          d.set(0, str);
+          yield* d.#data;
+        }
+      }());
+    }
+  }
+  get BYTES_PER_ELEMENT() {
+    return this.#data.BYTES_PER_ELEMENT * this.chars;
+  }
+  get byteLength() {
+    return this.#data.byteLength;
+  }
+  get byteOffset() {
+    return this.#data.byteOffset;
+  }
+  get buffer() {
+    return this.#data.buffer;
+  }
+  get length() {
+    return this.#data.length / this.chars;
+  }
+  get(idx) {
+    const offset = this.chars * idx;
+    let result = "";
+    for (let i = 0; i < this.chars; i++) {
+      result += String.fromCodePoint(this.#data[offset + i]);
+    }
+    return result.replace(/\u0000/g, "");
+  }
+  set(idx, value) {
+    const offset = this.chars * idx;
+    const view = this.#data.subarray(offset, offset + this.chars);
+    view.fill(0);
+    for (let i = 0; i < this.chars; i++) {
+      view[i] = value.codePointAt(i) ?? 0;
+    }
+  }
+  fill(value) {
+    this.set(0, value);
+    let encoded = this.#data.subarray(0, this.chars);
+    for (let i = 1; i < this.length; i++) {
+      this.#data.set(encoded, i * this.chars);
+    }
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.length; i++) {
+      yield this.get(i);
+    }
+  }
+}
+function json_encode_object(o) {
+  const str = JSON.stringify(o, null, 2);
+  return new TextEncoder().encode(str);
+}
+function json_decode_object(bytes) {
+  const str = new TextDecoder().decode(bytes);
+  return JSON.parse(str);
+}
+function byteswap_inplace(view, bytes_per_element2) {
+  const numFlips = bytes_per_element2 / 2;
+  const endByteIndex = bytes_per_element2 - 1;
+  let t = 0;
+  for (let i = 0; i < view.length; i += bytes_per_element2) {
+    for (let j = 0; j < numFlips; j += 1) {
+      t = view[i + j];
+      view[i + j] = view[i + endByteIndex - j];
+      view[i + endByteIndex - j] = t;
+    }
+  }
+}
+function get_ctr(data_type) {
+  if (data_type === "v2:object") {
+    return globalThis.Array;
+  }
+  let match = data_type.match(/v2:([US])(\d+)/);
+  if (match) {
+    let [, kind, chars] = match;
+    return (kind === "U" ? UnicodeStringArray : ByteStringArray).bind(null, Number(chars));
+  }
+  if (data_type === "string") {
+    return globalThis.Array;
+  }
+  let ctr = {
+    int8: Int8Array,
+    int16: Int16Array,
+    int32: Int32Array,
+    int64: globalThis.BigInt64Array,
+    uint8: Uint8Array,
+    uint16: Uint16Array,
+    uint32: Uint32Array,
+    uint64: globalThis.BigUint64Array,
+    float16: globalThis.Float16Array,
+    float32: Float32Array,
+    float64: Float64Array,
+    bool: BoolArray
+  }[data_type];
+  assert(ctr, `Unknown or unsupported data_type: ${data_type}`);
+  return ctr;
+}
+function get_strides(shape, order) {
+  const rank = shape.length;
+  if (typeof order === "string") {
+    order = order === "C" ? Array.from({ length: rank }, (_, i) => i) : Array.from({ length: rank }, (_, i) => rank - 1 - i);
+  }
+  assert(rank === order.length, "Order length must match the number of dimensions.");
+  let step = 1;
+  let stride = new Array(rank);
+  for (let i = order.length - 1; i >= 0; i--) {
+    stride[order[i]] = step;
+    step *= shape[order[i]];
+  }
+  return stride;
+}
+function create_chunk_key_encoder({ name, configuration }) {
+  if (name === "default") {
+    const separator = configuration?.separator ?? "/";
+    return (chunk_coords) => ["c", ...chunk_coords].join(separator);
+  }
+  if (name === "v2") {
+    const separator = configuration?.separator ?? ".";
+    return (chunk_coords) => chunk_coords.join(separator) || "0";
+  }
+  throw new Error(`Unknown chunk key encoding: ${name}`);
+}
+function coerce_dtype(dtype) {
+  if (dtype === "|O") {
+    return { data_type: "v2:object" };
+  }
+  let match = dtype.match(/^([<|>])(.*)$/);
+  assert(match, `Invalid dtype: ${dtype}`);
+  let [, endian, rest] = match;
+  let data_type = {
+    b1: "bool",
+    i1: "int8",
+    u1: "uint8",
+    i2: "int16",
+    u2: "uint16",
+    i4: "int32",
+    u4: "uint32",
+    i8: "int64",
+    u8: "uint64",
+    f2: "float16",
+    f4: "float32",
+    f8: "float64"
+  }[rest] ?? (rest.startsWith("S") || rest.startsWith("U") ? `v2:${rest}` : void 0);
+  assert(data_type, `Unsupported or unknown dtype: ${dtype}`);
+  if (endian === "|") {
+    return { data_type };
+  }
+  return { data_type, endian: endian === "<" ? "little" : "big" };
+}
+function v2_to_v3_array_metadata(meta, attributes = {}) {
+  let codecs = [];
+  let dtype = coerce_dtype(meta.dtype);
+  if (meta.order === "F") {
+    codecs.push({ name: "transpose", configuration: { order: "F" } });
+  }
+  if ("endian" in dtype && dtype.endian === "big") {
+    codecs.push({ name: "bytes", configuration: { endian: "big" } });
+  }
+  for (let { id, ...configuration } of meta.filters ?? []) {
+    codecs.push({ name: id, configuration });
+  }
+  if (meta.compressor) {
+    let { id, ...configuration } = meta.compressor;
+    codecs.push({ name: id, configuration });
+  }
+  return {
+    zarr_format: 3,
+    node_type: "array",
+    shape: meta.shape,
+    data_type: dtype.data_type,
+    chunk_grid: {
+      name: "regular",
+      configuration: {
+        chunk_shape: meta.chunks
+      }
+    },
+    chunk_key_encoding: {
+      name: "v2",
+      configuration: {
+        separator: meta.dimension_separator ?? "."
+      }
+    },
+    codecs,
+    fill_value: meta.fill_value,
+    attributes
+  };
+}
+function v2_to_v3_group_metadata(_meta, attributes = {}) {
+  return {
+    zarr_format: 3,
+    node_type: "group",
+    attributes
+  };
+}
+function is_dtype(dtype, query) {
+  if (query !== "number" && query !== "bigint" && query !== "boolean" && query !== "object" && query !== "string") {
+    return dtype === query;
+  }
+  let is_boolean = dtype === "bool";
+  if (query === "boolean")
+    return is_boolean;
+  let is_string = dtype.startsWith("v2:U") || dtype.startsWith("v2:S") || dtype === "string";
+  if (query === "string")
+    return is_string;
+  let is_bigint = dtype === "int64" || dtype === "uint64";
+  if (query === "bigint")
+    return is_bigint;
+  let is_object = dtype === "v2:object";
+  if (query === "object")
+    return is_object;
+  return !is_string && !is_bigint && !is_boolean && !is_object;
+}
+function is_sharding_codec(codec) {
+  return codec?.name === "sharding_indexed";
+}
+function ensure_correct_scalar(metadata) {
+  if ((metadata.data_type === "uint64" || metadata.data_type === "int64") && metadata.fill_value != null) {
+    return BigInt(metadata.fill_value);
+  }
+  return metadata.fill_value;
+}
+function rethrow_unless(error, ...errors) {
+  if (!errors.some((ErrorClass) => error instanceof ErrorClass)) {
+    throw error;
+  }
+}
+function assert(expression, msg = "") {
+  if (!expression) {
+    throw new Error(msg);
+  }
+}
+async function decompress(data, { format, signal }) {
+  const response = data instanceof Response ? data : new Response(data);
+  assert(response.body, "Response does not contain body.");
+  try {
+    const decompressedResponse = new Response(response.body.pipeThrough(new DecompressionStream(format), { signal }));
+    const buffer = await decompressedResponse.arrayBuffer();
+    return buffer;
+  } catch {
+    signal?.throwIfAborted();
+    throw new Error(`Failed to decode ${format}`);
+  }
+}
+class BitroundCodec {
+  constructor(configuration, _meta) {
+    this.kind = "array_to_array";
+    assert(configuration.keepbits >= 0, "keepbits must be zero or positive");
+  }
+  static fromConfig(configuration, meta) {
+    return new BitroundCodec(configuration, meta);
+  }
+  /**
+   * Encode a chunk of data with bit-rounding.
+   * @param _arr - The chunk to encode
+   */
+  encode(_arr) {
+    throw new Error("`BitroundCodec.encode` is not implemented. Please open an issue at https://github.com/manzt/zarrita.js/issues.");
+  }
+  /**
+   * Decode a chunk of data (no-op).
+   * @param arr - The chunk to decode
+   * @returns The decoded chunk
+   */
+  decode(arr) {
+    return arr;
+  }
+}
+const LITTLE_ENDIAN_OS = system_is_little_endian();
+function system_is_little_endian() {
+  const a = new Uint32Array([305419896]);
+  const b = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
+  return !(b[0] === 18);
+}
+function bytes_per_element(TypedArray) {
+  if ("BYTES_PER_ELEMENT" in TypedArray) {
+    return TypedArray.BYTES_PER_ELEMENT;
+  }
+  return 4;
+}
+class BytesCodec {
+  constructor(configuration, meta) {
+    this.kind = "array_to_bytes";
+    this.#endian = configuration?.endian;
+    this.#TypedArray = get_ctr(meta.data_type);
+    this.#shape = meta.shape;
+    this.#stride = get_strides(meta.shape, "C");
+    const sample = new this.#TypedArray(0);
+    this.#BYTES_PER_ELEMENT = sample.BYTES_PER_ELEMENT;
+  }
+  #stride;
+  #TypedArray;
+  #BYTES_PER_ELEMENT;
+  #shape;
+  #endian;
+  static fromConfig(configuration, meta) {
+    return new BytesCodec(configuration, meta);
+  }
+  encode(arr) {
+    let bytes = new Uint8Array(arr.data.buffer);
+    if (LITTLE_ENDIAN_OS && this.#endian === "big") {
+      byteswap_inplace(bytes, bytes_per_element(this.#TypedArray));
+    }
+    return bytes;
+  }
+  decode(bytes) {
+    if (LITTLE_ENDIAN_OS && this.#endian === "big") {
+      byteswap_inplace(bytes, bytes_per_element(this.#TypedArray));
+    }
+    return {
+      data: new this.#TypedArray(bytes.buffer, bytes.byteOffset, bytes.byteLength / this.#BYTES_PER_ELEMENT),
+      shape: this.#shape,
+      stride: this.#stride
+    };
+  }
+}
+class Crc32cCodec {
+  constructor() {
+    this.kind = "bytes_to_bytes";
+  }
+  static fromConfig() {
+    return new Crc32cCodec();
+  }
+  encode(_) {
+    throw new Error("Not implemented");
+  }
+  decode(arr) {
+    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength - 4);
+  }
+}
+class GzipCodec {
+  constructor() {
+    this.kind = "bytes_to_bytes";
+  }
+  static fromConfig(_) {
+    return new GzipCodec();
+  }
+  encode(_bytes) {
+    throw new Error("Gzip encoding is not enabled by default. Please register a custom codec with `numcodecs/gzip`.");
+  }
+  async decode(bytes) {
+    const buffer = await decompress(bytes, { format: "gzip" });
+    return new Uint8Array(buffer);
+  }
+}
+function throw_on_nan_replacer(_key, value) {
+  assert(!Number.isNaN(value), "JsonCodec allow_nan is false but NaN was encountered during encoding.");
+  assert(value !== Number.POSITIVE_INFINITY, "JsonCodec allow_nan is false but Infinity was encountered during encoding.");
+  assert(value !== Number.NEGATIVE_INFINITY, "JsonCodec allow_nan is false but -Infinity was encountered during encoding.");
+  return value;
+}
+function sort_keys_replacer(_key, value) {
+  return value instanceof Object && !Array.isArray(value) ? Object.keys(value).sort().reduce((sorted, key) => {
+    sorted[key] = value[key];
+    return sorted;
+  }, {}) : value;
+}
+class JsonCodec {
+  constructor(configuration = {}) {
+    this.kind = "array_to_bytes";
+    this.configuration = configuration;
+    const { encoding = "utf-8", skipkeys = false, ensure_ascii = true, check_circular = true, allow_nan = true, sort_keys = true, indent, strict = true } = configuration;
+    let separators = configuration.separators;
+    if (!separators) {
+      if (!indent) {
+        separators = [",", ":"];
+      } else {
+        separators = [", ", ": "];
+      }
+    }
+    this.#encoder_config = {
+      encoding,
+      skipkeys,
+      ensure_ascii,
+      check_circular,
+      allow_nan,
+      indent,
+      separators,
+      sort_keys
+    };
+    this.#decoder_config = { strict };
+  }
+  #encoder_config;
+  #decoder_config;
+  static fromConfig(configuration) {
+    return new JsonCodec(configuration);
+  }
+  encode(buf) {
+    const { indent, encoding, ensure_ascii, check_circular, allow_nan, sort_keys } = this.#encoder_config;
+    assert(encoding === "utf-8", "JsonCodec does not yet support non-utf-8 encoding.");
+    const replacer_functions = [];
+    assert(check_circular, "JsonCodec does not yet support skipping the check for circular references during encoding.");
+    if (!allow_nan) {
+      replacer_functions.push(throw_on_nan_replacer);
+    }
+    if (sort_keys) {
+      replacer_functions.push(sort_keys_replacer);
+    }
+    const items = Array.from(buf.data);
+    items.push("|O");
+    items.push(buf.shape);
+    let replacer;
+    if (replacer_functions.length) {
+      replacer = (key, value) => {
+        let new_value = value;
+        for (let sub_replacer of replacer_functions) {
+          new_value = sub_replacer(key, new_value);
+        }
+        return new_value;
+      };
+    }
+    let json_str = JSON.stringify(items, replacer, indent);
+    if (ensure_ascii) {
+      json_str = json_str.replace(/[\u007F-\uFFFF]/g, (chr) => {
+        const full_str = `0000${chr.charCodeAt(0).toString(16)}`;
+        const sub_str = full_str.substring(full_str.length - 4);
+        return `\\u${sub_str}`;
+      });
+    }
+    return new TextEncoder().encode(json_str);
+  }
+  decode(bytes) {
+    const { strict } = this.#decoder_config;
+    assert(strict, "JsonCodec does not yet support non-strict decoding.");
+    const items = json_decode_object(bytes);
+    const shape = items.pop();
+    items.pop();
+    assert(shape, "0D not implemented for JsonCodec.");
+    const stride = get_strides(shape, "C");
+    const data = items;
+    return { data, shape, stride };
+  }
+}
+function proxy(arr) {
+  if (arr instanceof BoolArray || arr instanceof ByteStringArray || arr instanceof UnicodeStringArray) {
+    const arrp = new Proxy(arr, {
+      get(target, prop) {
+        return target.get(Number(prop));
+      },
+      set(target, prop, value) {
+        target.set(Number(prop), value);
+        return true;
+      }
+    });
+    return arrp;
+  }
+  return arr;
+}
+function empty_like(chunk, order) {
+  let data;
+  if (chunk.data instanceof ByteStringArray || chunk.data instanceof UnicodeStringArray) {
+    data = new chunk.constructor(
+      // @ts-expect-error
+      chunk.data.length,
+      chunk.data.chars
+    );
+  } else {
+    data = new chunk.constructor(chunk.data.length);
+  }
+  return {
+    data,
+    shape: chunk.shape,
+    stride: get_strides(chunk.shape, order)
+  };
+}
+function convert_array_order(src, target) {
+  let out = empty_like(src, target);
+  let n_dims = src.shape.length;
+  let size = src.data.length;
+  let index = Array(n_dims).fill(0);
+  let src_data = proxy(src.data);
+  let out_data = proxy(out.data);
+  for (let src_idx = 0; src_idx < size; src_idx++) {
+    let out_idx = 0;
+    for (let dim = 0; dim < n_dims; dim++) {
+      out_idx += index[dim] * out.stride[dim];
+    }
+    out_data[out_idx] = src_data[src_idx];
+    index[0] += 1;
+    for (let dim = 0; dim < n_dims; dim++) {
+      if (index[dim] === src.shape[dim]) {
+        if (dim + 1 === n_dims) {
+          break;
+        }
+        index[dim] = 0;
+        index[dim + 1] += 1;
+      }
+    }
+  }
+  return out;
+}
+function get_order(chunk) {
+  let rank = chunk.shape.length;
+  assert(rank === chunk.stride.length, "Shape and stride must have the same length.");
+  return chunk.stride.map((s, i) => ({ stride: s, index: i })).sort((a, b) => b.stride - a.stride).map((entry) => entry.index);
+}
+function matches_order(chunk, target) {
+  let source = get_order(chunk);
+  assert(source.length === target.length, "Orders must match");
+  return source.every((dim, i) => dim === target[i]);
+}
+class TransposeCodec {
+  constructor(configuration, meta) {
+    this.kind = "array_to_array";
+    let value = configuration.order ?? "C";
+    let rank = meta.shape.length;
+    let order = new Array(rank);
+    let inverseOrder = new Array(rank);
+    if (value === "C") {
+      for (let i = 0; i < rank; ++i) {
+        order[i] = i;
+        inverseOrder[i] = i;
+      }
+    } else if (value === "F") {
+      for (let i = 0; i < rank; ++i) {
+        order[i] = rank - i - 1;
+        inverseOrder[i] = rank - i - 1;
+      }
+    } else {
+      order = value;
+      order.forEach((x, i) => {
+        assert(inverseOrder[x] === void 0, `Invalid permutation: ${JSON.stringify(value)}`);
+        inverseOrder[x] = i;
+      });
+    }
+    this.#order = order;
+    this.#inverseOrder = inverseOrder;
+  }
+  #order;
+  #inverseOrder;
+  static fromConfig(configuration, meta) {
+    return new TransposeCodec(configuration, meta);
+  }
+  encode(arr) {
+    if (matches_order(arr, this.#inverseOrder)) {
+      return arr;
+    }
+    return convert_array_order(arr, this.#inverseOrder);
+  }
+  decode(arr) {
+    return {
+      data: arr.data,
+      shape: arr.shape,
+      stride: get_strides(arr.shape, this.#order)
+    };
+  }
+}
+class VLenUTF8 {
+  constructor(shape) {
+    this.kind = "array_to_bytes";
+    this.#shape = shape;
+    this.#strides = get_strides(shape, "C");
+  }
+  #shape;
+  #strides;
+  static fromConfig(_, meta) {
+    return new VLenUTF8(meta.shape);
+  }
+  encode(_chunk) {
+    throw new Error("Method not implemented.");
+  }
+  decode(bytes) {
+    let decoder = new TextDecoder();
+    let view = new DataView(bytes.buffer);
+    let data = Array(view.getUint32(0, true));
+    let pos = 4;
+    for (let i = 0; i < data.length; i++) {
+      let item_length = view.getUint32(pos, true);
+      pos += 4;
+      data[i] = decoder.decode(bytes.buffer.slice(pos, pos + item_length));
+      pos += item_length;
+    }
+    return { data, shape: this.#shape, stride: this.#strides };
+  }
+}
+class ZlibCodec {
+  constructor() {
+    this.kind = "bytes_to_bytes";
+  }
+  static fromConfig(_) {
+    return new ZlibCodec();
+  }
+  encode(_bytes) {
+    throw new Error("Zlib encoding is not enabled by default. Please register a codec with `numcodecs/zlib`.");
+  }
+  async decode(bytes) {
+    const buffer = await decompress(bytes, { format: "deflate" });
+    return new Uint8Array(buffer);
+  }
+}
+function create_default_registry() {
+  return (/* @__PURE__ */ new Map()).set("blosc", () => import("./blosc-DvQQ1ST0.js").then((m) => m.default)).set("lz4", () => import("./lz4-BIbM36RN.js").then((m) => m.default)).set("zstd", () => import("./zstd-CO575QiM.js").then((m) => m.default)).set("gzip", () => GzipCodec).set("zlib", () => ZlibCodec).set("transpose", () => TransposeCodec).set("bytes", () => BytesCodec).set("crc32c", () => Crc32cCodec).set("vlen-utf8", () => VLenUTF8).set("json2", () => JsonCodec).set("bitround", () => BitroundCodec);
+}
+const registry = create_default_registry();
+function create_codec_pipeline(chunk_metadata) {
+  let codecs;
+  return {
+    async encode(chunk) {
+      if (!codecs)
+        codecs = await load_codecs(chunk_metadata);
+      for (const codec of codecs.array_to_array) {
+        chunk = await codec.encode(chunk);
+      }
+      let bytes = await codecs.array_to_bytes.encode(chunk);
+      for (const codec of codecs.bytes_to_bytes) {
+        bytes = await codec.encode(bytes);
+      }
+      return bytes;
+    },
+    async decode(bytes) {
+      if (!codecs)
+        codecs = await load_codecs(chunk_metadata);
+      for (let i = codecs.bytes_to_bytes.length - 1; i >= 0; i--) {
+        bytes = await codecs.bytes_to_bytes[i].decode(bytes);
+      }
+      let chunk = await codecs.array_to_bytes.decode(bytes);
+      for (let i = codecs.array_to_array.length - 1; i >= 0; i--) {
+        chunk = await codecs.array_to_array[i].decode(chunk);
+      }
+      return chunk;
+    }
+  };
+}
+async function load_codecs(chunk_meta) {
+  let promises = chunk_meta.codecs.map(async (meta) => {
+    let Codec = await registry.get(meta.name)?.();
+    assert(Codec, `Unknown codec: ${meta.name}`);
+    return { Codec, meta };
+  });
+  let array_to_array = [];
+  let array_to_bytes;
+  let bytes_to_bytes = [];
+  for await (let { Codec, meta } of promises) {
+    let codec = Codec.fromConfig(meta.configuration, chunk_meta);
+    switch (codec.kind) {
+      case "array_to_array":
+        array_to_array.push(codec);
+        break;
+      case "array_to_bytes":
+        array_to_bytes = codec;
+        break;
+      default:
+        bytes_to_bytes.push(codec);
+    }
+  }
+  if (!array_to_bytes) {
+    assert(is_typed_array_like_meta(chunk_meta), `Cannot encode ${chunk_meta.data_type} to bytes without a codec`);
+    array_to_bytes = BytesCodec.fromConfig({ endian: "little" }, chunk_meta);
+  }
+  return { array_to_array, array_to_bytes, bytes_to_bytes };
+}
+function is_typed_array_like_meta(meta) {
+  return meta.data_type !== "v2:object" && meta.data_type !== "string";
+}
+class NodeNotFoundError extends Error {
+  constructor(context, options = {}) {
+    super(`Node not found: ${context}`, options);
+    this.name = "NodeNotFoundError";
+  }
+}
+class KeyError extends Error {
+  constructor(path) {
+    super(`Missing key: ${path}`);
+    this.name = "KeyError";
+  }
+}
+async function get_consolidated_metadata(store, metadataKeyOption) {
+  const metadataKey = metadataKeyOption ?? ".zmetadata";
+  let bytes = await store.get(`/${metadataKey}`);
+  if (!bytes) {
+    throw new NodeNotFoundError("v2 consolidated metadata", {
+      cause: new KeyError(`/${metadataKey}`)
+    });
+  }
+  let meta = json_decode_object(bytes);
+  assert(meta.zarr_consolidated_format === 1, "Unsupported consolidated format.");
+  return meta;
+}
+function is_meta_key(key) {
+  return key.endsWith(".zarray") || key.endsWith(".zgroup") || key.endsWith(".zattrs") || key.endsWith("zarr.json");
+}
+function is_v3(meta) {
+  return "zarr_format" in meta && meta.zarr_format === 3;
+}
+async function withConsolidated(store, opts = {}) {
+  let v2_meta = await get_consolidated_metadata(store, opts.metadataKey);
+  let known_meta = {};
+  for (let [key, value] of Object.entries(v2_meta.metadata)) {
+    known_meta[`/${key}`] = value;
+  }
+  return {
+    async get(...args) {
+      let [key, opts2] = args;
+      if (known_meta[key]) {
+        return json_encode_object(known_meta[key]);
+      }
+      let maybe_bytes = await store.get(key, opts2);
+      if (is_meta_key(key) && maybe_bytes) {
+        let meta = json_decode_object(maybe_bytes);
+        known_meta[key] = meta;
+      }
+      return maybe_bytes;
+    },
+    // Delegate range requests to the underlying store.
+    // Note: Supporting range requests for consolidated metadata is possible
+    // but unlikely to be useful enough to justify the effort.
+    getRange: store.getRange?.bind(store),
+    contents() {
+      let contents = [];
+      for (let [key, value] of Object.entries(known_meta)) {
+        let parts = key.split("/");
+        let filename = parts.pop();
+        let path = parts.join("/") || "/";
+        if (filename === ".zarray")
+          contents.push({ path, kind: "array" });
+        if (filename === ".zgroup")
+          contents.push({ path, kind: "group" });
+        if (is_v3(value)) {
+          contents.push({ path, kind: value.node_type });
+        }
+      }
+      return contents;
+    }
+  };
+}
+const MAX_BIG_UINT = 18446744073709551615n;
+function create_sharded_chunk_getter(location, shard_shape, encode_shard_key, sharding_config) {
+  assert(location.store.getRange, "Store does not support range requests");
+  let get_range = location.store.getRange.bind(location.store);
+  let index_shape = shard_shape.map((d, i) => d / sharding_config.chunk_shape[i]);
+  let index_codec = create_codec_pipeline({
+    data_type: "uint64",
+    shape: [...index_shape, 2],
+    codecs: sharding_config.index_codecs
+  });
+  let cache = {};
+  return async (chunk_coord, options) => {
+    let shard_coord = chunk_coord.map((d, i) => Math.floor(d / index_shape[i]));
+    let shard_path = location.resolve(encode_shard_key(shard_coord)).path;
+    let index;
+    if (shard_path in cache) {
+      index = cache[shard_path];
+    } else {
+      let checksum_size = 4;
+      let index_size = 16 * index_shape.reduce((a, b) => a * b, 1);
+      let bytes = await get_range(shard_path, {
+        suffixLength: index_size + checksum_size
+      }, options);
+      index = cache[shard_path] = bytes ? await index_codec.decode(bytes) : null;
+    }
+    if (index === null) {
+      return void 0;
+    }
+    let { data, shape, stride } = index;
+    let linear_offset = chunk_coord.map((d, i) => d % shape[i]).reduce((acc, sel, idx) => acc + sel * stride[idx], 0);
+    let offset = data[linear_offset];
+    let length = data[linear_offset + 1];
+    if (offset === MAX_BIG_UINT && length === MAX_BIG_UINT) {
+      return void 0;
+    }
+    return get_range(shard_path, {
+      offset: Number(offset),
+      length: Number(length)
+    }, options);
+  };
+}
+var _a;
+class Location {
+  constructor(store, path = "/") {
+    this.store = store;
+    this.path = path;
+  }
+  resolve(path) {
+    let root2 = new URL(`file://${this.path.endsWith("/") ? this.path : `${this.path}/`}`);
+    return new Location(this.store, decodeURIComponent(new URL(path, root2).pathname));
+  }
+}
+class Group extends Location {
+  constructor(store, path, metadata) {
+    super(store, path);
+    this.kind = "group";
+    this.#metadata = metadata;
+  }
+  #metadata;
+  get attrs() {
+    return this.#metadata.attributes;
+  }
+}
+function get_array_order(codecs) {
+  const maybe_transpose_codec = codecs.find((c) => c.name === "transpose");
+  return maybe_transpose_codec?.configuration?.order ?? "C";
+}
+const CONTEXT_MARKER = Symbol("zarrita.context");
+function create_context(location, metadata) {
+  let { configuration } = metadata.codecs.find(is_sharding_codec) ?? {};
+  let shared_context = {
+    encode_chunk_key: create_chunk_key_encoder(metadata.chunk_key_encoding),
+    TypedArray: get_ctr(metadata.data_type),
+    fill_value: metadata.fill_value
+  };
+  if (configuration) {
+    let native_order2 = get_array_order(configuration.codecs);
+    return {
+      ...shared_context,
+      kind: "sharded",
+      chunk_shape: configuration.chunk_shape,
+      codec: create_codec_pipeline({
+        data_type: metadata.data_type,
+        shape: configuration.chunk_shape,
+        codecs: configuration.codecs
+      }),
+      get_strides(shape) {
+        return get_strides(shape, native_order2);
+      },
+      get_chunk_bytes: create_sharded_chunk_getter(location, metadata.chunk_grid.configuration.chunk_shape, shared_context.encode_chunk_key, configuration)
+    };
+  }
+  let native_order = get_array_order(metadata.codecs);
+  return {
+    ...shared_context,
+    kind: "regular",
+    chunk_shape: metadata.chunk_grid.configuration.chunk_shape,
+    codec: create_codec_pipeline({
+      data_type: metadata.data_type,
+      shape: metadata.chunk_grid.configuration.chunk_shape,
+      codecs: metadata.codecs
+    }),
+    get_strides(shape) {
+      return get_strides(shape, native_order);
+    },
+    async get_chunk_bytes(chunk_coords, options) {
+      let chunk_key = shared_context.encode_chunk_key(chunk_coords);
+      let chunk_path = location.resolve(chunk_key).path;
+      return location.store.get(chunk_path, options);
+    }
+  };
+}
+let Array$1 = class Array2 extends (_a = Location, _a) {
+  constructor(store, path, metadata) {
+    super(store, path);
+    this.kind = "array";
+    this.#metadata = {
+      ...metadata,
+      fill_value: ensure_correct_scalar(metadata)
+    };
+    this[CONTEXT_MARKER] = create_context(this, metadata);
+  }
+  #metadata;
+  get attrs() {
+    return this.#metadata.attributes;
+  }
+  get shape() {
+    return this.#metadata.shape;
+  }
+  get chunks() {
+    return this[CONTEXT_MARKER].chunk_shape;
+  }
+  get dtype() {
+    return this.#metadata.data_type;
+  }
+  async getChunk(chunk_coords, options) {
+    let context = this[CONTEXT_MARKER];
+    let maybe_bytes = await context.get_chunk_bytes(chunk_coords, options);
+    if (!maybe_bytes) {
+      let size = context.chunk_shape.reduce((a, b) => a * b, 1);
+      let data = new context.TypedArray(size);
+      data.fill(context.fill_value);
+      return {
+        data,
+        shape: context.chunk_shape,
+        stride: context.get_strides(context.chunk_shape)
+      };
+    }
+    return context.codec.decode(maybe_bytes);
+  }
+  /**
+   * A helper method to narrow `zarr.Array` Dtype.
+   *
+   * ```typescript
+   * let arr: zarr.Array<DataType, FetchStore> = zarr.open(store, { kind: "array" });
+   *
+   * // Option 1: narrow by scalar type (e.g. "bool", "raw", "bigint", "number")
+   * if (arr.is("bigint")) {
+   *   // zarr.Array<"int64" | "uint64", FetchStore>
+   * }
+   *
+   * // Option 3: exact match
+   * if (arr.is("float32")) {
+   *   // zarr.Array<"float32", FetchStore, "/">
+   * }
+   * ```
+   */
+  is(query) {
+    return is_dtype(this.dtype, query);
+  }
+};
+let VERSION_COUNTER = create_version_counter();
+function create_version_counter() {
+  let version_counts = /* @__PURE__ */ new WeakMap();
+  function get_counts(store) {
+    let counts = version_counts.get(store) ?? { v2: 0, v3: 0 };
+    version_counts.set(store, counts);
+    return counts;
+  }
+  return {
+    increment(store, version) {
+      get_counts(store)[version] += 1;
+    },
+    version_max(store) {
+      let counts = get_counts(store);
+      return counts.v3 > counts.v2 ? "v3" : "v2";
+    }
+  };
+}
+async function load_attrs(location) {
+  let meta_bytes = await location.store.get(location.resolve(".zattrs").path);
+  if (!meta_bytes)
+    return {};
+  return json_decode_object(meta_bytes);
+}
+async function open_v2(location, options = {}) {
+  let loc = "store" in location ? location : new Location(location);
+  let attrs = {};
+  if (options.attrs ?? true)
+    attrs = await load_attrs(loc);
+  if (options.kind === "array")
+    return open_array_v2(loc, attrs);
+  if (options.kind === "group")
+    return open_group_v2(loc, attrs);
+  return open_array_v2(loc, attrs).catch((err) => {
+    rethrow_unless(err, NodeNotFoundError);
+    return open_group_v2(loc, attrs);
+  });
+}
+async function open_array_v2(location, attrs) {
+  let { path } = location.resolve(".zarray");
+  let meta = await location.store.get(path);
+  if (!meta) {
+    throw new NodeNotFoundError("v2 array", {
+      cause: new KeyError(path)
+    });
+  }
+  VERSION_COUNTER.increment(location.store, "v2");
+  return new Array$1(location.store, location.path, v2_to_v3_array_metadata(json_decode_object(meta), attrs));
+}
+async function open_group_v2(location, attrs) {
+  let { path } = location.resolve(".zgroup");
+  let meta = await location.store.get(path);
+  if (!meta) {
+    throw new NodeNotFoundError("v2 group", {
+      cause: new KeyError(path)
+    });
+  }
+  VERSION_COUNTER.increment(location.store, "v2");
+  return new Group(location.store, location.path, v2_to_v3_group_metadata(json_decode_object(meta), attrs));
+}
+async function _open_v3(location) {
+  let { store, path } = location.resolve("zarr.json");
+  let meta = await location.store.get(path);
+  if (!meta) {
+    throw new NodeNotFoundError("v3 array or group", {
+      cause: new KeyError(path)
+    });
+  }
+  let meta_doc = json_decode_object(meta);
+  if (meta_doc.node_type === "array") {
+    meta_doc.fill_value = ensure_correct_scalar(meta_doc);
+  }
+  return meta_doc.node_type === "array" ? new Array$1(store, location.path, meta_doc) : new Group(store, location.path, meta_doc);
+}
+async function open_v3(location, options = {}) {
+  let loc = "store" in location ? location : new Location(location);
+  let node = await _open_v3(loc);
+  VERSION_COUNTER.increment(loc.store, "v3");
+  if (options.kind === void 0)
+    return node;
+  if (options.kind === "array" && node instanceof Array$1)
+    return node;
+  if (options.kind === "group" && node instanceof Group)
+    return node;
+  let kind = node instanceof Array$1 ? "array" : "group";
+  throw new Error(`Expected node of kind ${options.kind}, found ${kind}.`);
+}
+async function open(location, options = {}) {
+  let store = "store" in location ? location.store : location;
+  let version_max = VERSION_COUNTER.version_max(store);
+  let open_primary = version_max === "v2" ? open.v2 : open.v3;
+  let open_secondary = version_max === "v2" ? open.v3 : open.v2;
+  return open_primary(location, options).catch((err) => {
+    rethrow_unless(err, NodeNotFoundError);
+    return open_secondary(location, options);
+  });
+}
+open.v2 = open_v2;
+open.v3 = open_v3;
+function readBlobAsArrayBuffer(blob) {
+  if (blob.arrayBuffer) {
+    return blob.arrayBuffer();
+  }
+  return new Promise((resolve2, reject) => {
+    const reader = new FileReader();
+    reader.addEventListener("loadend", () => {
+      resolve2(reader.result);
+    });
+    reader.addEventListener("error", reject);
+    reader.readAsArrayBuffer(blob);
+  });
+}
+async function readBlobAsUint8Array(blob) {
+  const arrayBuffer = await readBlobAsArrayBuffer(blob);
+  return new Uint8Array(arrayBuffer);
+}
+function isBlob(v) {
+  return typeof Blob !== "undefined" && v instanceof Blob;
+}
+function isSharedArrayBuffer(b) {
+  return typeof SharedArrayBuffer !== "undefined" && b instanceof SharedArrayBuffer;
+}
+const isNode = typeof process !== "undefined" && process.versions && typeof process.versions.node !== "undefined" && typeof process.versions.electron === "undefined";
+function isTypedArraySameAsArrayBuffer(typedArray) {
+  return typedArray.byteOffset === 0 && typedArray.byteLength === typedArray.buffer.byteLength;
+}
+class ArrayBufferReader {
+  constructor(arrayBufferOrView) {
+    this.typedArray = arrayBufferOrView instanceof ArrayBuffer || isSharedArrayBuffer(arrayBufferOrView) ? new Uint8Array(arrayBufferOrView) : new Uint8Array(arrayBufferOrView.buffer, arrayBufferOrView.byteOffset, arrayBufferOrView.byteLength);
+  }
+  async getLength() {
+    return this.typedArray.byteLength;
+  }
+  async read(offset, length) {
+    return new Uint8Array(this.typedArray.buffer, this.typedArray.byteOffset + offset, length);
+  }
+}
+let BlobReader$1 = class BlobReader {
+  constructor(blob) {
+    this.blob = blob;
+  }
+  async getLength() {
+    return this.blob.size;
+  }
+  async read(offset, length) {
+    const blob = this.blob.slice(offset, offset + length);
+    const arrayBuffer = await readBlobAsArrayBuffer(blob);
+    return new Uint8Array(arrayBuffer);
+  }
+  async sliceAsBlob(offset, length, type = "") {
+    return this.blob.slice(offset, offset + length, type);
+  }
+};
+function inflate(data, buf) {
+  var u8 = Uint8Array;
+  if (data[0] == 3 && data[1] == 0) return buf ? buf : new u8(0);
+  var bitsF = _bitsF, bitsE = _bitsE, decodeTiny = _decodeTiny, get17 = _get17;
+  var noBuf = buf == null;
+  if (noBuf) buf = new u8(data.length >>> 2 << 3);
+  var BFINAL = 0, BTYPE = 0, HLIT = 0, HDIST = 0, HCLEN = 0, ML = 0, MD = 0;
+  var off = 0, pos = 0;
+  var lmap, dmap;
+  while (BFINAL == 0) {
+    BFINAL = bitsF(data, pos, 1);
+    BTYPE = bitsF(data, pos + 1, 2);
+    pos += 3;
+    if (BTYPE == 0) {
+      if ((pos & 7) != 0) pos += 8 - (pos & 7);
+      var p8 = (pos >>> 3) + 4, len = data[p8 - 4] | data[p8 - 3] << 8;
+      if (noBuf) buf = _check(buf, off + len);
+      buf.set(new u8(data.buffer, data.byteOffset + p8, len), off);
+      pos = p8 + len << 3;
+      off += len;
+      continue;
+    }
+    if (noBuf) buf = _check(buf, off + (1 << 17));
+    if (BTYPE == 1) {
+      lmap = U.flmap;
+      dmap = U.fdmap;
+      ML = (1 << 9) - 1;
+      MD = (1 << 5) - 1;
+    }
+    if (BTYPE == 2) {
+      HLIT = bitsE(data, pos, 5) + 257;
+      HDIST = bitsE(data, pos + 5, 5) + 1;
+      HCLEN = bitsE(data, pos + 10, 4) + 4;
+      pos += 14;
+      for (var i = 0; i < 38; i += 2) {
+        U.itree[i] = 0;
+        U.itree[i + 1] = 0;
+      }
+      var tl = 1;
+      for (var i = 0; i < HCLEN; i++) {
+        var l = bitsE(data, pos + i * 3, 3);
+        U.itree[(U.ordr[i] << 1) + 1] = l;
+        if (l > tl) tl = l;
+      }
+      pos += 3 * HCLEN;
+      makeCodes(U.itree, tl);
+      codes2map(U.itree, tl, U.imap);
+      lmap = U.lmap;
+      dmap = U.dmap;
+      pos = decodeTiny(U.imap, (1 << tl) - 1, HLIT + HDIST, data, pos, U.ttree);
+      var mx0 = _copyOut(U.ttree, 0, HLIT, U.ltree);
+      ML = (1 << mx0) - 1;
+      var mx1 = _copyOut(U.ttree, HLIT, HDIST, U.dtree);
+      MD = (1 << mx1) - 1;
+      makeCodes(U.ltree, mx0);
+      codes2map(U.ltree, mx0, lmap);
+      makeCodes(U.dtree, mx1);
+      codes2map(U.dtree, mx1, dmap);
+    }
+    while (true) {
+      var code = lmap[get17(data, pos) & ML];
+      pos += code & 15;
+      var lit = code >>> 4;
+      if (lit >>> 8 == 0) {
+        buf[off++] = lit;
+      } else if (lit == 256) {
+        break;
+      } else {
+        var end = off + lit - 254;
+        if (lit > 264) {
+          var ebs = U.ldef[lit - 257];
+          end = off + (ebs >>> 3) + bitsE(data, pos, ebs & 7);
+          pos += ebs & 7;
+        }
+        var dcode = dmap[get17(data, pos) & MD];
+        pos += dcode & 15;
+        var dlit = dcode >>> 4;
+        var dbs = U.ddef[dlit], dst = (dbs >>> 4) + bitsF(data, pos, dbs & 15);
+        pos += dbs & 15;
+        if (noBuf) buf = _check(buf, off + (1 << 17));
+        while (off < end) {
+          buf[off] = buf[off++ - dst];
+          buf[off] = buf[off++ - dst];
+          buf[off] = buf[off++ - dst];
+          buf[off] = buf[off++ - dst];
+        }
+        off = end;
+      }
+    }
+  }
+  return buf.length == off ? buf : buf.slice(0, off);
+}
+function _check(buf, len) {
+  var bl = buf.length;
+  if (len <= bl) return buf;
+  var nbuf = new Uint8Array(Math.max(bl << 1, len));
+  nbuf.set(buf, 0);
+  return nbuf;
+}
+function _decodeTiny(lmap, LL, len, data, pos, tree) {
+  var bitsE = _bitsE, get17 = _get17;
+  var i = 0;
+  while (i < len) {
+    var code = lmap[get17(data, pos) & LL];
+    pos += code & 15;
+    var lit = code >>> 4;
+    if (lit <= 15) {
+      tree[i] = lit;
+      i++;
+    } else {
+      var ll = 0, n = 0;
+      if (lit == 16) {
+        n = 3 + bitsE(data, pos, 2);
+        pos += 2;
+        ll = tree[i - 1];
+      } else if (lit == 17) {
+        n = 3 + bitsE(data, pos, 3);
+        pos += 3;
+      } else if (lit == 18) {
+        n = 11 + bitsE(data, pos, 7);
+        pos += 7;
+      }
+      var ni = i + n;
+      while (i < ni) {
+        tree[i] = ll;
+        i++;
+      }
+    }
+  }
+  return pos;
+}
+function _copyOut(src, off, len, tree) {
+  var mx = 0, i = 0, tl = tree.length >>> 1;
+  while (i < len) {
+    var v = src[i + off];
+    tree[i << 1] = 0;
+    tree[(i << 1) + 1] = v;
+    if (v > mx) mx = v;
+    i++;
+  }
+  while (i < tl) {
+    tree[i << 1] = 0;
+    tree[(i << 1) + 1] = 0;
+    i++;
+  }
+  return mx;
+}
+function makeCodes(tree, MAX_BITS) {
+  var max_code = tree.length;
+  var code, bits, n, i, len;
+  var bl_count = U.bl_count;
+  for (var i = 0; i <= MAX_BITS; i++) bl_count[i] = 0;
+  for (i = 1; i < max_code; i += 2) bl_count[tree[i]]++;
+  var next_code = U.next_code;
+  code = 0;
+  bl_count[0] = 0;
+  for (bits = 1; bits <= MAX_BITS; bits++) {
+    code = code + bl_count[bits - 1] << 1;
+    next_code[bits] = code;
+  }
+  for (n = 0; n < max_code; n += 2) {
+    len = tree[n + 1];
+    if (len != 0) {
+      tree[n] = next_code[len];
+      next_code[len]++;
+    }
+  }
+}
+function codes2map(tree, MAX_BITS, map) {
+  var max_code = tree.length;
+  var r15 = U.rev15;
+  for (var i = 0; i < max_code; i += 2) if (tree[i + 1] != 0) {
+    var lit = i >> 1;
+    var cl = tree[i + 1], val = lit << 4 | cl;
+    var rest = MAX_BITS - cl, i0 = tree[i] << rest, i1 = i0 + (1 << rest);
+    while (i0 != i1) {
+      var p0 = r15[i0] >>> 15 - MAX_BITS;
+      map[p0] = val;
+      i0++;
+    }
+  }
+}
+function revCodes(tree, MAX_BITS) {
+  var r15 = U.rev15, imb = 15 - MAX_BITS;
+  for (var i = 0; i < tree.length; i += 2) {
+    var i0 = tree[i] << MAX_BITS - tree[i + 1];
+    tree[i] = r15[i0] >>> imb;
+  }
+}
+function _bitsE(dt, pos, length) {
+  return (dt[pos >>> 3] | dt[(pos >>> 3) + 1] << 8) >>> (pos & 7) & (1 << length) - 1;
+}
+function _bitsF(dt, pos, length) {
+  return (dt[pos >>> 3] | dt[(pos >>> 3) + 1] << 8 | dt[(pos >>> 3) + 2] << 16) >>> (pos & 7) & (1 << length) - 1;
+}
+function _get17(dt, pos) {
+  return (dt[pos >>> 3] | dt[(pos >>> 3) + 1] << 8 | dt[(pos >>> 3) + 2] << 16) >>> (pos & 7);
+}
+const U = function() {
+  var u16 = Uint16Array, u32 = Uint32Array;
+  return {
+    next_code: new u16(16),
+    bl_count: new u16(16),
+    ordr: [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15],
+    of0: [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 999, 999, 999],
+    exb: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0],
+    ldef: new u16(32),
+    df0: [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 65535, 65535],
+    dxb: [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0],
+    ddef: new u32(32),
+    flmap: new u16(512),
+    fltree: [],
+    fdmap: new u16(32),
+    fdtree: [],
+    lmap: new u16(32768),
+    ltree: [],
+    ttree: [],
+    dmap: new u16(32768),
+    dtree: [],
+    imap: new u16(512),
+    itree: [],
+    //rev9 : new u16(  512)
+    rev15: new u16(1 << 15),
+    lhst: new u32(286),
+    dhst: new u32(30),
+    ihst: new u32(19),
+    lits: new u32(15e3),
+    strt: new u16(1 << 16),
+    prev: new u16(1 << 15)
+  };
+}();
+(function() {
+  var len = 1 << 15;
+  for (var i = 0; i < len; i++) {
+    var x = i;
+    x = (x & 2863311530) >>> 1 | (x & 1431655765) << 1;
+    x = (x & 3435973836) >>> 2 | (x & 858993459) << 2;
+    x = (x & 4042322160) >>> 4 | (x & 252645135) << 4;
+    x = (x & 4278255360) >>> 8 | (x & 16711935) << 8;
+    U.rev15[i] = (x >>> 16 | x << 16) >>> 17;
+  }
+  function pushV(tgt, n, sv) {
+    while (n-- != 0) tgt.push(0, sv);
+  }
+  for (var i = 0; i < 32; i++) {
+    U.ldef[i] = U.of0[i] << 3 | U.exb[i];
+    U.ddef[i] = U.df0[i] << 4 | U.dxb[i];
+  }
+  pushV(U.fltree, 144, 8);
+  pushV(U.fltree, 255 - 143, 9);
+  pushV(U.fltree, 279 - 255, 7);
+  pushV(U.fltree, 287 - 279, 8);
+  makeCodes(U.fltree, 9);
+  codes2map(U.fltree, 9, U.flmap);
+  revCodes(U.fltree, 9);
+  pushV(U.fdtree, 32, 5);
+  makeCodes(U.fdtree, 5);
+  codes2map(U.fdtree, 5, U.fdmap);
+  revCodes(U.fdtree, 5);
+  pushV(U.itree, 19, 0);
+  pushV(U.ltree, 286, 0);
+  pushV(U.dtree, 30, 0);
+  pushV(U.ttree, 320, 0);
+})();
+({
+  table: function() {
+    var tab = new Uint32Array(256);
+    for (var n = 0; n < 256; n++) {
+      var c = n;
+      for (var k = 0; k < 8; k++) {
+        if (c & 1) c = 3988292384 ^ c >>> 1;
+        else c = c >>> 1;
+      }
+      tab[n] = c;
+    }
+    return tab;
+  }()
+});
+function inflateRaw(file, buf) {
+  return inflate(file, buf);
+}
+const config = {
+  numWorkers: 1,
+  workerURL: "",
+  useWorkers: false
+};
+let nextId = 0;
+const waitingForWorkerQueue = [];
+function startWorker(url) {
+  return new Promise((resolve2, reject) => {
+    const worker = new Worker(url);
+    worker.onmessage = (e) => {
+      if (e.data === "start") {
+        worker.onerror = void 0;
+        worker.onmessage = void 0;
+        resolve2(worker);
+      } else {
+        reject(new Error(`unexpected message: ${e.data}`));
+      }
+    };
+    worker.onerror = reject;
+  });
+}
+function dynamicRequire(mod, request) {
+  return mod.require ? mod.require(request) : {};
+}
+(function() {
+  if (isNode) {
+    const { Worker: Worker2 } = dynamicRequire(module, "worker_threads");
+    return {
+      async createWorker(url) {
+        return new Worker2(url);
+      },
+      addEventListener(worker, fn) {
+        worker.on("message", (data) => {
+          fn({ target: worker, data });
+        });
+      },
+      async terminate(worker) {
+        await worker.terminate();
+      }
+    };
+  } else {
+    return {
+      async createWorker(url) {
+        try {
+          const worker = await startWorker(url);
+          return worker;
+        } catch (e) {
+          console.warn("could not load worker:", url);
+        }
+        let text;
+        try {
+          const req = await fetch(url, { mode: "cors" });
+          if (!req.ok) {
+            throw new Error(`could not load: ${url}`);
+          }
+          text = await req.text();
+          url = URL.createObjectURL(new Blob([text], { type: "application/javascript" }));
+          const worker = await startWorker(url);
+          config.workerURL = url;
+          return worker;
+        } catch (e) {
+          console.warn("could not load worker via fetch:", url);
+        }
+        if (text !== void 0) {
+          try {
+            url = `data:application/javascript;base64,${btoa(text)}`;
+            const worker = await startWorker(url);
+            config.workerURL = url;
+            return worker;
+          } catch (e) {
+            console.warn("could not load worker via dataURI");
+          }
+        }
+        console.warn("workers will not be used");
+        throw new Error("can not start workers");
+      },
+      addEventListener(worker, fn) {
+        worker.addEventListener("message", fn);
+      },
+      async terminate(worker) {
+        worker.terminate();
+      }
+    };
+  }
+})();
+function inflateRawLocal(src, uncompressedSize, type, resolve2) {
+  const dst = new Uint8Array(uncompressedSize);
+  inflateRaw(src, dst);
+  resolve2(type ? new Blob([dst], { type }) : dst.buffer);
+}
+async function processWaitingForWorkerQueue() {
+  if (waitingForWorkerQueue.length === 0) {
+    return;
+  }
+  while (waitingForWorkerQueue.length) {
+    const { src, uncompressedSize, type, resolve: resolve2 } = waitingForWorkerQueue.shift();
+    let data = src;
+    if (isBlob(src)) {
+      data = await readBlobAsUint8Array(src);
+    }
+    inflateRawLocal(data, uncompressedSize, type, resolve2);
+  }
+}
+function inflateRawAsync(src, uncompressedSize, type) {
+  return new Promise((resolve2, reject) => {
+    waitingForWorkerQueue.push({ src, uncompressedSize, type, resolve: resolve2, reject, id: nextId++ });
+    processWaitingForWorkerQueue();
+  });
+}
+function dosDateTimeToDate(date, time) {
+  const day = date & 31;
+  const month = (date >> 5 & 15) - 1;
+  const year = (date >> 9 & 127) + 1980;
+  const millisecond = 0;
+  const second = (time & 31) * 2;
+  const minute = time >> 5 & 63;
+  const hour = time >> 11 & 31;
+  return new Date(year, month, day, hour, minute, second, millisecond);
+}
+class ZipEntry {
+  constructor(reader, rawEntry) {
+    this._reader = reader;
+    this._rawEntry = rawEntry;
+    this.name = rawEntry.name;
+    this.nameBytes = rawEntry.nameBytes;
+    this.size = rawEntry.uncompressedSize;
+    this.compressedSize = rawEntry.compressedSize;
+    this.comment = rawEntry.comment;
+    this.commentBytes = rawEntry.commentBytes;
+    this.compressionMethod = rawEntry.compressionMethod;
+    this.lastModDate = dosDateTimeToDate(rawEntry.lastModFileDate, rawEntry.lastModFileTime);
+    this.isDirectory = rawEntry.uncompressedSize === 0 && rawEntry.name.endsWith("/");
+    this.encrypted = !!(rawEntry.generalPurposeBitFlag & 1);
+    this.externalFileAttributes = rawEntry.externalFileAttributes;
+    this.versionMadeBy = rawEntry.versionMadeBy;
+  }
+  // returns a promise that returns a Blob for this entry
+  async blob(type = "application/octet-stream") {
+    return await readEntryDataAsBlob(this._reader, this._rawEntry, type);
+  }
+  // returns a promise that returns an ArrayBuffer for this entry
+  async arrayBuffer() {
+    return await readEntryDataAsArrayBuffer(this._reader, this._rawEntry);
+  }
+  // returns text, assumes the text is valid utf8. If you want more options decode arrayBuffer yourself
+  async text() {
+    const buffer = await this.arrayBuffer();
+    return decodeBuffer(new Uint8Array(buffer));
+  }
+  // returns text with JSON.parse called on it. If you want more options decode arrayBuffer yourself
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+}
+const EOCDR_WITHOUT_COMMENT_SIZE = 22;
+const MAX_COMMENT_SIZE = 65535;
+const EOCDR_SIGNATURE = 101010256;
+const ZIP64_EOCDR_SIGNATURE = 101075792;
+async function readAs(reader, offset, length) {
+  return await reader.read(offset, length);
+}
+async function readAsBlobOrTypedArray(reader, offset, length, type) {
+  if (reader.sliceAsBlob) {
+    return await reader.sliceAsBlob(offset, length, type);
+  }
+  return await reader.read(offset, length);
+}
+const crc$1 = {
+  unsigned() {
+    return 0;
+  }
+};
+function getUint16LE(uint8View, offset) {
+  return uint8View[offset] + uint8View[offset + 1] * 256;
+}
+function getUint32LE(uint8View, offset) {
+  return uint8View[offset] + uint8View[offset + 1] * 256 + uint8View[offset + 2] * 65536 + uint8View[offset + 3] * 16777216;
+}
+function getUint64LE(uint8View, offset) {
+  return getUint32LE(uint8View, offset) + getUint32LE(uint8View, offset + 4) * 4294967296;
+}
+const utf8Decoder = new TextDecoder();
+function decodeBuffer(uint8View, isUTF8) {
+  if (isSharedArrayBuffer(uint8View.buffer)) {
+    uint8View = new Uint8Array(uint8View);
+  }
+  return utf8Decoder.decode(uint8View);
+}
+async function findEndOfCentralDirector(reader, totalLength) {
+  const size = Math.min(EOCDR_WITHOUT_COMMENT_SIZE + MAX_COMMENT_SIZE, totalLength);
+  const readStart = totalLength - size;
+  const data = await readAs(reader, readStart, size);
+  for (let i = size - EOCDR_WITHOUT_COMMENT_SIZE; i >= 0; --i) {
+    if (getUint32LE(data, i) !== EOCDR_SIGNATURE) {
+      continue;
+    }
+    const eocdr = new Uint8Array(data.buffer, data.byteOffset + i, data.byteLength - i);
+    const diskNumber = getUint16LE(eocdr, 4);
+    if (diskNumber !== 0) {
+      throw new Error(`multi-volume zip files are not supported. This is volume: ${diskNumber}`);
+    }
+    const entryCount = getUint16LE(eocdr, 10);
+    const centralDirectorySize = getUint32LE(eocdr, 12);
+    const centralDirectoryOffset = getUint32LE(eocdr, 16);
+    const commentLength = getUint16LE(eocdr, 20);
+    const expectedCommentLength = eocdr.length - EOCDR_WITHOUT_COMMENT_SIZE;
+    if (commentLength !== expectedCommentLength) {
+      throw new Error(`invalid comment length. expected: ${expectedCommentLength}, actual: ${commentLength}`);
+    }
+    const commentBytes = new Uint8Array(eocdr.buffer, eocdr.byteOffset + 22, commentLength);
+    const comment = decodeBuffer(commentBytes);
+    if (entryCount === 65535 || centralDirectoryOffset === 4294967295) {
+      return await readZip64CentralDirectory(reader, readStart + i, comment, commentBytes);
+    } else {
+      return await readEntries(reader, centralDirectoryOffset, centralDirectorySize, entryCount, comment, commentBytes);
+    }
+  }
+  throw new Error("could not find end of central directory. maybe not zip file");
+}
+const END_OF_CENTRAL_DIRECTORY_LOCATOR_SIGNATURE = 117853008;
+async function readZip64CentralDirectory(reader, offset, comment, commentBytes) {
+  const zip64EocdlOffset = offset - 20;
+  const eocdl = await readAs(reader, zip64EocdlOffset, 20);
+  if (getUint32LE(eocdl, 0) !== END_OF_CENTRAL_DIRECTORY_LOCATOR_SIGNATURE) {
+    throw new Error("invalid zip64 end of central directory locator signature");
+  }
+  const zip64EocdrOffset = getUint64LE(eocdl, 8);
+  const zip64Eocdr = await readAs(reader, zip64EocdrOffset, 56);
+  if (getUint32LE(zip64Eocdr, 0) !== ZIP64_EOCDR_SIGNATURE) {
+    throw new Error("invalid zip64 end of central directory record signature");
+  }
+  const entryCount = getUint64LE(zip64Eocdr, 32);
+  const centralDirectorySize = getUint64LE(zip64Eocdr, 40);
+  const centralDirectoryOffset = getUint64LE(zip64Eocdr, 48);
+  return readEntries(reader, centralDirectoryOffset, centralDirectorySize, entryCount, comment, commentBytes);
+}
+const CENTRAL_DIRECTORY_FILE_HEADER_SIGNATURE = 33639248;
+async function readEntries(reader, centralDirectoryOffset, centralDirectorySize, rawEntryCount, comment, commentBytes) {
+  let readEntryCursor = 0;
+  const allEntriesBuffer = await readAs(reader, centralDirectoryOffset, centralDirectorySize);
+  const rawEntries = [];
+  for (let e = 0; e < rawEntryCount; ++e) {
+    const buffer = allEntriesBuffer.subarray(readEntryCursor, readEntryCursor + 46);
+    const signature = getUint32LE(buffer, 0);
+    if (signature !== CENTRAL_DIRECTORY_FILE_HEADER_SIGNATURE) {
+      throw new Error(`invalid central directory file header signature: 0x${signature.toString(16)}`);
+    }
+    const rawEntry = {
+      // 4 - Version made by
+      versionMadeBy: getUint16LE(buffer, 4),
+      // 6 - Version needed to extract (minimum)
+      versionNeededToExtract: getUint16LE(buffer, 6),
+      // 8 - General purpose bit flag
+      generalPurposeBitFlag: getUint16LE(buffer, 8),
+      // 10 - Compression method
+      compressionMethod: getUint16LE(buffer, 10),
+      // 12 - File last modification time
+      lastModFileTime: getUint16LE(buffer, 12),
+      // 14 - File last modification date
+      lastModFileDate: getUint16LE(buffer, 14),
+      // 16 - CRC-32
+      crc32: getUint32LE(buffer, 16),
+      // 20 - Compressed size
+      compressedSize: getUint32LE(buffer, 20),
+      // 24 - Uncompressed size
+      uncompressedSize: getUint32LE(buffer, 24),
+      // 28 - File name length (n)
+      fileNameLength: getUint16LE(buffer, 28),
+      // 30 - Extra field length (m)
+      extraFieldLength: getUint16LE(buffer, 30),
+      // 32 - File comment length (k)
+      fileCommentLength: getUint16LE(buffer, 32),
+      // 34 - Disk number where file starts
+      // 36 - Internal file attributes
+      internalFileAttributes: getUint16LE(buffer, 36),
+      // 38 - External file attributes
+      externalFileAttributes: getUint32LE(buffer, 38),
+      // 42 - Relative offset of local file header
+      relativeOffsetOfLocalHeader: getUint32LE(buffer, 42)
+    };
+    if (rawEntry.generalPurposeBitFlag & 64) {
+      throw new Error("strong encryption is not supported");
+    }
+    readEntryCursor += 46;
+    const data = allEntriesBuffer.subarray(readEntryCursor, readEntryCursor + rawEntry.fileNameLength + rawEntry.extraFieldLength + rawEntry.fileCommentLength);
+    rawEntry.nameBytes = data.slice(0, rawEntry.fileNameLength);
+    rawEntry.name = decodeBuffer(rawEntry.nameBytes);
+    const fileCommentStart = rawEntry.fileNameLength + rawEntry.extraFieldLength;
+    const extraFieldBuffer = data.slice(rawEntry.fileNameLength, fileCommentStart);
+    rawEntry.extraFields = [];
+    let i = 0;
+    while (i < extraFieldBuffer.length - 3) {
+      const headerId = getUint16LE(extraFieldBuffer, i + 0);
+      const dataSize = getUint16LE(extraFieldBuffer, i + 2);
+      const dataStart = i + 4;
+      const dataEnd = dataStart + dataSize;
+      if (dataEnd > extraFieldBuffer.length) {
+        throw new Error("extra field length exceeds extra field buffer size");
+      }
+      rawEntry.extraFields.push({
+        id: headerId,
+        data: extraFieldBuffer.slice(dataStart, dataEnd)
+      });
+      i = dataEnd;
+    }
+    rawEntry.commentBytes = data.slice(fileCommentStart, fileCommentStart + rawEntry.fileCommentLength);
+    rawEntry.comment = decodeBuffer(rawEntry.commentBytes);
+    readEntryCursor += data.length;
+    if (rawEntry.uncompressedSize === 4294967295 || rawEntry.compressedSize === 4294967295 || rawEntry.relativeOffsetOfLocalHeader === 4294967295) {
+      const zip64ExtraField = rawEntry.extraFields.find((e2) => e2.id === 1);
+      if (!zip64ExtraField) {
+        throw new Error("expected zip64 extended information extra field");
+      }
+      const zip64EiefBuffer = zip64ExtraField.data;
+      let index = 0;
+      if (rawEntry.uncompressedSize === 4294967295) {
+        if (index + 8 > zip64EiefBuffer.length) {
+          throw new Error("zip64 extended information extra field does not include uncompressed size");
+        }
+        rawEntry.uncompressedSize = getUint64LE(zip64EiefBuffer, index);
+        index += 8;
+      }
+      if (rawEntry.compressedSize === 4294967295) {
+        if (index + 8 > zip64EiefBuffer.length) {
+          throw new Error("zip64 extended information extra field does not include compressed size");
+        }
+        rawEntry.compressedSize = getUint64LE(zip64EiefBuffer, index);
+        index += 8;
+      }
+      if (rawEntry.relativeOffsetOfLocalHeader === 4294967295) {
+        if (index + 8 > zip64EiefBuffer.length) {
+          throw new Error("zip64 extended information extra field does not include relative header offset");
+        }
+        rawEntry.relativeOffsetOfLocalHeader = getUint64LE(zip64EiefBuffer, index);
+        index += 8;
+      }
+    }
+    const nameField = rawEntry.extraFields.find((e2) => e2.id === 28789 && e2.data.length >= 6 && // too short to be meaningful
+    e2.data[0] === 1 && // Version       1 byte      version of this extra field, currently 1
+    getUint32LE(e2.data, 1), crc$1.unsigned(rawEntry.nameBytes));
+    if (nameField) {
+      rawEntry.fileName = decodeBuffer(nameField.data.slice(5));
+    }
+    if (rawEntry.compressionMethod === 0) {
+      let expectedCompressedSize = rawEntry.uncompressedSize;
+      if ((rawEntry.generalPurposeBitFlag & 1) !== 0) {
+        expectedCompressedSize += 12;
+      }
+      if (rawEntry.compressedSize !== expectedCompressedSize) {
+        throw new Error(`compressed size mismatch for stored file: ${rawEntry.compressedSize} != ${expectedCompressedSize}`);
+      }
+    }
+    rawEntries.push(rawEntry);
+  }
+  const zip = {
+    comment,
+    commentBytes
+  };
+  return {
+    zip,
+    entries: rawEntries.map((e) => new ZipEntry(reader, e))
+  };
+}
+async function readEntryDataHeader(reader, rawEntry) {
+  if (rawEntry.generalPurposeBitFlag & 1) {
+    throw new Error("encrypted entries not supported");
+  }
+  const buffer = await readAs(reader, rawEntry.relativeOffsetOfLocalHeader, 30);
+  const totalLength = await reader.getLength();
+  const signature = getUint32LE(buffer, 0);
+  if (signature !== 67324752) {
+    throw new Error(`invalid local file header signature: 0x${signature.toString(16)}`);
+  }
+  const fileNameLength = getUint16LE(buffer, 26);
+  const extraFieldLength = getUint16LE(buffer, 28);
+  const localFileHeaderEnd = rawEntry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength;
+  let decompress2;
+  if (rawEntry.compressionMethod === 0) {
+    decompress2 = false;
+  } else if (rawEntry.compressionMethod === 8) {
+    decompress2 = true;
+  } else {
+    throw new Error(`unsupported compression method: ${rawEntry.compressionMethod}`);
+  }
+  const fileDataStart = localFileHeaderEnd;
+  const fileDataEnd = fileDataStart + rawEntry.compressedSize;
+  if (rawEntry.compressedSize !== 0) {
+    if (fileDataEnd > totalLength) {
+      throw new Error(`file data overflows file bounds: ${fileDataStart} +  ${rawEntry.compressedSize}  > ${totalLength}`);
+    }
+  }
+  return {
+    decompress: decompress2,
+    fileDataStart
+  };
+}
+async function readEntryDataAsArrayBuffer(reader, rawEntry) {
+  const { decompress: decompress2, fileDataStart } = await readEntryDataHeader(reader, rawEntry);
+  if (!decompress2) {
+    const dataView = await readAs(reader, fileDataStart, rawEntry.compressedSize);
+    return isTypedArraySameAsArrayBuffer(dataView) ? dataView.buffer : dataView.slice().buffer;
+  }
+  const typedArrayOrBlob = await readAsBlobOrTypedArray(reader, fileDataStart, rawEntry.compressedSize);
+  const result = await inflateRawAsync(typedArrayOrBlob, rawEntry.uncompressedSize);
+  return result;
+}
+async function readEntryDataAsBlob(reader, rawEntry, type) {
+  const { decompress: decompress2, fileDataStart } = await readEntryDataHeader(reader, rawEntry);
+  if (!decompress2) {
+    const typedArrayOrBlob2 = await readAsBlobOrTypedArray(reader, fileDataStart, rawEntry.compressedSize, type);
+    if (isBlob(typedArrayOrBlob2)) {
+      return typedArrayOrBlob2;
+    }
+    return new Blob([isSharedArrayBuffer(typedArrayOrBlob2.buffer) ? new Uint8Array(typedArrayOrBlob2) : typedArrayOrBlob2], { type });
+  }
+  const typedArrayOrBlob = await readAsBlobOrTypedArray(reader, fileDataStart, rawEntry.compressedSize);
+  const result = await inflateRawAsync(typedArrayOrBlob, rawEntry.uncompressedSize, type);
+  return result;
+}
+async function unzipRaw(source) {
+  let reader;
+  if (typeof Blob !== "undefined" && source instanceof Blob) {
+    reader = new BlobReader$1(source);
+  } else if (source instanceof ArrayBuffer || source && source.buffer && source.buffer instanceof ArrayBuffer) {
+    reader = new ArrayBufferReader(source);
+  } else if (isSharedArrayBuffer(source) || isSharedArrayBuffer(source.buffer)) {
+    reader = new ArrayBufferReader(source);
+  } else if (typeof source === "string") {
+    const req = await fetch(source);
+    if (!req.ok) {
+      throw new Error(`failed http request ${source}, status: ${req.status}: ${req.statusText}`);
+    }
+    const blob = await req.blob();
+    reader = new BlobReader$1(blob);
+  } else if (typeof source.getLength === "function" && typeof source.read === "function") {
+    reader = source;
+  } else {
+    throw new Error("unsupported source type");
+  }
+  const totalLength = await reader.getLength();
+  if (totalLength > Number.MAX_SAFE_INTEGER) {
+    throw new Error(`file too large. size: ${totalLength}. Only file sizes up 4503599627370496 bytes are supported`);
+  }
+  return await findEndOfCentralDirector(reader, totalLength);
+}
+async function unzip(source) {
+  const { zip, entries } = await unzipRaw(source);
+  return {
+    zip,
+    entries: Object.fromEntries(entries.map((v) => [v.name, v]))
+  };
+}
+function isZipEntryInternal(entry) {
+  if (!("compressionMethod" in entry) || !("_rawEntry" in entry)) {
+    return false;
+  }
+  const rawEntry = entry._rawEntry;
+  return typeof entry.compressionMethod === "number" && typeof rawEntry === "object" && rawEntry !== null && "relativeOffsetOfLocalHeader" in rawEntry && typeof rawEntry.relativeOffsetOfLocalHeader === "number";
+}
+class BlobReader2 {
+  constructor(blob) {
+    this.blob = blob;
+  }
+  async getLength() {
+    return this.blob.size;
+  }
+  async read(offset, length) {
+    const blob = this.blob.slice(offset, offset + length);
+    return new Uint8Array(await blob.arrayBuffer());
+  }
+}
+class HTTPRangeReader {
+  #overrides;
+  constructor(url, opts = {}) {
+    this.url = url;
+    this.#overrides = opts.overrides ?? {};
+  }
+  async getLength() {
+    if (this.length === void 0) {
+      const req = await fetch(this.url, {
+        ...this.#overrides,
+        method: "HEAD"
+      });
+      assert$1(req.ok, `failed http request ${this.url}, status: ${req.status}: ${req.statusText}`);
+      this.length = Number(req.headers.get("content-length"));
+      if (Number.isNaN(this.length)) {
+        throw Error("could not get length");
+      }
+    }
+    return this.length;
+  }
+  async read(offset, size) {
+    if (size === 0) {
+      return new Uint8Array(0);
+    }
+    const req = await fetch_range(this.url, offset, size, this.#overrides);
+    assert$1(req.ok, `failed http request ${this.url}, status: ${req.status} offset: ${offset} size: ${size}: ${req.statusText}`);
+    return new Uint8Array(await req.arrayBuffer());
+  }
+}
+class ZipFileStore {
+  constructor(reader, opts = {}) {
+    this.reader = reader;
+    this.info = unzip(reader).then((info) => {
+      if (opts.transformEntries) {
+        info.entries = opts.transformEntries(info.entries);
+      }
+      return info;
+    });
+  }
+  /**
+   * Compute the byte offset where entry data begins in the zip file.
+   * This requires reading the local file header to get filename and extra field lengths.
+   */
+  async getEntryDataOffset(entry) {
+    const localHeaderOffset = entry._rawEntry.relativeOffsetOfLocalHeader;
+    const header = await this.reader.read(localHeaderOffset, 30);
+    const fileNameLength = header[26] + header[27] * 256;
+    const extraFieldLength = header[28] + header[29] * 256;
+    return localHeaderOffset + 30 + fileNameLength + extraFieldLength;
+  }
+  async get(key) {
+    let entry = (await this.info).entries[strip_prefix(key)];
+    if (!entry)
+      return;
+    return new Uint8Array(await entry.arrayBuffer());
+  }
+  async getRange(key, range) {
+    const entry = (await this.info).entries[strip_prefix(key)];
+    if (!entry)
+      return void 0;
+    if (!isZipEntryInternal(entry)) {
+      throw new Error("ZipFileStore.getRange requires internal unzipit properties that are not available. This may indicate an incompatible version of unzipit.");
+    }
+    if (entry.compressionMethod !== 0) {
+      const bytes = await this.get(key);
+      if (!bytes)
+        return void 0;
+      if ("suffixLength" in range) {
+        return bytes.slice(-range.suffixLength);
+      }
+      return bytes.slice(range.offset, range.offset + range.length);
+    }
+    const dataOffset = await this.getEntryDataOffset(entry);
+    if ("suffixLength" in range) {
+      const start = dataOffset + entry.size - range.suffixLength;
+      return this.reader.read(start, range.suffixLength);
+    }
+    return this.reader.read(dataOffset + range.offset, range.length);
+  }
+  async has(key) {
+    return strip_prefix(key) in (await this.info).entries;
+  }
+  static fromUrl(href, opts = {}) {
+    return new ZipFileStore(new HTTPRangeReader(href, opts), opts);
+  }
+  static fromBlob(blob, opts = {}) {
+    return new ZipFileStore(new BlobReader2(blob), opts);
+  }
+}
+function transformEntriesForZipFileStore(entries) {
+  const topLevelZarrDirectories = new Set(Object.keys(entries).map((k) => k.split("/")[0]).filter((firstPathItem) => firstPathItem?.endsWith(".zarr")));
+  if (topLevelZarrDirectories.size === 0) {
+    return entries;
+  }
+  if (topLevelZarrDirectories.size > 1) {
+    throw Error("expected exactly one top-level .zarr directory");
+  }
+  const topLevelZarrDirectory = Array.from(topLevelZarrDirectories)[0];
+  const newEntries = Object.fromEntries(Object.entries(entries).map(([k, v]) => {
+    let newKey = k;
+    if (k.split("/")[0] === topLevelZarrDirectory) {
+      newKey = k.substring(topLevelZarrDirectory.length + 1);
+    }
+    return [newKey, v];
+  }));
+  return newEntries;
+}
+function flattenOmeAttrs(rootAttrs) {
+  if (rootAttrs && typeof rootAttrs.ome === "object" && rootAttrs.ome !== null) {
+    return { ...rootAttrs.ome, ...rootAttrs };
+  }
+  return rootAttrs;
+}
+class AbstractAutoConfig2 {
+  constructor(parsedStore) {
+    const { url, fileType, zmetadata } = parsedStore;
+    this.url = url;
+    this.fileType = fileType;
+    this.zmetadata = zmetadata;
+  }
+  // eslint-disable-next-line class-methods-use-this
+  addFiles(vc, dataset) {
+    throw new Error("The addFiles() method has not been implemented.");
+  }
+  // eslint-disable-next-line class-methods-use-this
+  addViews(vc, dataset, layoutOption) {
+    throw new Error("The addViews() method has not been implemented.");
+  }
+}
+class AnnDataAutoConfig extends AbstractAutoConfig2 {
+  getOptions() {
+    const { zmetadata } = this;
+    const options = {
+      obsEmbedding: [],
+      obsSets: []
+    };
+    zmetadata.forEach(({ path, attrs }) => {
+      const lowerPath = path.toLowerCase();
+      const relPath = path.substring(1);
+      if (["/x"].includes(lowerPath)) {
+        options.obsFeatureMatrix = {
+          path: relPath
+          // TODO: Also check the shape of X.
+          // If X is very large, try to initialize initial-filtering properties
+          // (will require that /var contains a boolean column however.)
+        };
+      }
+      if (["/obsm/x_spatial", "/obsm/spatial"].includes(lowerPath)) {
+        options.obsLocations = {
+          path: relPath
+        };
+      }
+      if (["/obsm/x_umap", "/obsm/umap"].includes(lowerPath)) {
+        options.obsEmbedding.push({ path: relPath, embeddingType: "UMAP" });
+      }
+      if (["/obsm/x_tsne", "/obsm/tsne"].includes(lowerPath)) {
+        options.obsEmbedding.push({ path: relPath, embeddingType: "t-SNE" });
+      }
+      if (["/obsm/x_pca", "/obsm/pca"].includes(lowerPath)) {
+        options.obsEmbedding.push({ path: relPath, embeddingType: "PCA" });
+      }
+      const supportedObsSetsPaths = [
+        "cluster",
+        "clusters",
+        "subcluster",
+        "cell_type",
+        "celltype",
+        "leiden",
+        "louvain",
+        "disease",
+        "organism",
+        "self_reported_ethnicity",
+        "tissue",
+        "sex"
+      ].map((colname) => `/obs/${colname}`);
+      if (supportedObsSetsPaths.includes(lowerPath)) {
+        const name = relPath.split("/").at(-1);
+        options.obsSets.push({ path: relPath, name });
+      }
+    });
+    return options;
+  }
+  addFiles(vc, dataset) {
+    const { url, fileType } = this;
+    dataset.addFile({
+      url,
+      fileType,
+      options: this.getOptions()
+      // TODO: coordination values?
+    });
+  }
+  // eslint-disable-next-line class-methods-use-this
+  addViews(vc, dataset, layoutOption) {
+  }
+}
+class SpatialDataAutoConfig extends AbstractAutoConfig2 {
+  getOptions() {
+    const { zmetadata } = this;
+    const options = {};
+    const availableElements = zmetadata.filter(({ path }) => {
+      const relPath = path.substring(1);
+      return relPath.match(/^(tables|table|images|labels|shapes|points)\/([^/]*)$/);
+    });
+    availableElements.forEach(({ path, attrs }) => {
+      const relPath = path.substring(1);
+      const omeAttrs = flattenOmeAttrs(attrs);
+      const firstCoordinateSystem = omeAttrs?.multiscales?.[0]?.coordinateTransformations?.[0]?.output?.name;
+      if (relPath.match(/^(images)\/([^/]*)$/)) {
+        options.image = {
+          path: relPath,
+          coordinateSystem: firstCoordinateSystem
+          // TODO: support a fileUid property in the schema?
+        };
+      }
+      if (relPath.match(/^(labels)\/([^/]*)$/)) {
+        options.obsSegmentations = {
+          path: relPath,
+          coordinateSystem: firstCoordinateSystem
+          // TODO: support a fileUid property in the schema?
+        };
+      }
+      if (relPath.match(/^(shapes)\/([^/]*)$/)) {
+        options.obsSegmentations = {
+          path: relPath,
+          coordinateSystem: firstCoordinateSystem
+        };
+      }
+      if (relPath.match(/^(tables|table)\/([^/]*)$/)) {
+        const tableEls = zmetadata.filter(({ path: subpath }) => subpath.startsWith(path));
+        const hasX = tableEls.find((el) => el.path === `${path}/X`);
+        if (hasX) {
+          options.obsFeatureMatrix = {
+            path: hasX.path.substring(1)
+            // region: null,
+          };
+        }
+      }
+    });
+    return options;
+  }
+  addFiles(vc, dataset) {
+    const { url, fileType } = this;
+    dataset.addFile({
+      url,
+      fileType,
+      options: this.getOptions()
+      // TODO: coordination values?
+    });
+  }
+  // eslint-disable-next-line class-methods-use-this
+  addViews(vc, dataset, layoutOption) {
+    const options = this.getOptions();
+    const spatialView = vc.addView(dataset, "spatialBeta");
+    const lcView = vc.addView(dataset, "layerControllerBeta");
+    const controlViews = [lcView];
+    if (options.obsSets) {
+      const obsSets = vc.addView(dataset, "obsSets");
+      controlViews.push(obsSets);
+    }
+    if (options.obsFeatureMatrix) {
+      const featureList = vc.addView(dataset, "featureList");
+      controlViews.push(featureList);
+    }
+    vc.layout(hconcat(spatialView, vconcat(...controlViews)));
+  }
+}
+class OmeAutoConfig extends AbstractAutoConfig2 {
+  addFiles(vc, dataset) {
+    const { url, fileType } = this;
+    dataset.addFile({
+      url,
+      fileType
+      // TODO: options?
+      // TODO: coordination values?
+    });
+  }
+  // eslint-disable-next-line class-methods-use-this
+  addViews(vc, dataset, layoutOption) {
+    const spatialView = vc.addView(dataset, "spatialBeta");
+    const lcView = vc.addView(dataset, "layerControllerBeta");
+    vc.layout(hconcat(spatialView, lcView));
+  }
+}
+const FILE_TYPE_DELIM = "$";
+const fileTypeToExtensions = {
+  [FileType.IMAGE_OME_TIFF]: [".ome.tif", ".ome.tiff", ".ome.tf2", ".ome.tf8"],
+  [FileType.IMAGE_OME_ZARR]: [".ome.zarr"],
+  [FileType.IMAGE_OME_ZARR_ZIP]: [".ome.zarr.zip"],
+  [FileType.ANNDATA_ZARR]: [".ad.zarr", ".h5ad.zarr", ".adata.zarr", ".anndata.zarr"],
+  [FileType.ANNDATA_ZARR_ZIP]: [".ad.zarr.zip", ".h5ad.zarr.zip", ".adata.zarr.zip", ".anndata.zarr.zip"],
+  // TODO: how to handle h5ad-based AnnData (since needs reference JSON file).
+  // Perhaps just assume one H5AD+one JSON (or .ref.json) file correspond to each other?
+  [FileType.SPATIALDATA_ZARR]: [".sd.zarr", ".sdata.zarr", ".spatialdata.zarr"],
+  [FileType.SPATIALDATA_ZARR_ZIP]: [".sd.zarr.zip", ".sdata.zarr.zip", ".spatialdata.zarr.zip"]
+};
+const fileTypeToClass = {
+  // OME-TIFF
+  [FileType.IMAGE_OME_TIFF]: OmeAutoConfig,
+  [FileType.OBS_SEGMENTATIONS_OME_TIFF]: OmeAutoConfig,
+  // OME-Zarr
+  [FileType.IMAGE_OME_ZARR]: OmeAutoConfig,
+  [FileType.IMAGE_OME_ZARR_ZIP]: OmeAutoConfig,
+  [FileType.OBS_SEGMENTATIONS_OME_ZARR]: OmeAutoConfig,
+  [FileType.OBS_SEGMENTATIONS_OME_ZARR_ZIP]: OmeAutoConfig,
+  // AnnData
+  [FileType.ANNDATA_ZARR]: AnnDataAutoConfig,
+  [FileType.ANNDATA_ZARR_ZIP]: AnnDataAutoConfig,
+  // SpatialData
+  [FileType.SPATIALDATA_ZARR]: SpatialDataAutoConfig,
+  [FileType.SPATIALDATA_ZARR_ZIP]: SpatialDataAutoConfig
+};
+const ZARR_FILETYPES = [
+  FileType.ANNDATA_ZARR,
+  FileType.ANNDATA_ZARR_ZIP,
+  FileType.SPATIALDATA_ZARR,
+  FileType.SPATIALDATA_ZARR_ZIP,
+  FileType.IMAGE_OME_ZARR,
+  FileType.IMAGE_OME_ZARR_ZIP,
+  FileType.OBS_SEGMENTATIONS_OME_ZARR,
+  FileType.OBS_SEGMENTATIONS_OME_ZARR_ZIP
+];
+function urlToFileType(url) {
+  const match = Object.entries(fileTypeToExtensions).find(
+    // eslint-disable-next-line no-unused-vars
+    ([fileType, extensions]) => extensions.some((ext) => url.endsWith(ext))
+  );
+  if (match) {
+    return match[0];
+  }
+  throw new Error("The file extension contained in the URL did not map to a supported fileType.");
+}
+function getStore(parsedUrl) {
+  const { fileType, url } = parsedUrl;
+  if (!ZARR_FILETYPES.includes(fileType)) {
+    return null;
+  }
+  return fileType.endsWith(".zip") ? ZipFileStore.fromUrl(url, {
+    transformEntries: transformEntriesForZipFileStore
+  }) : new FetchStore(url);
+}
+function ensureStores(parsedUrls) {
+  return parsedUrls.map((parsedUrl) => {
+    if (parsedUrl.store) {
+      return parsedUrl;
+    }
+    const store = getStore(parsedUrl);
+    return {
+      ...parsedUrl,
+      store
+    };
+  });
+}
+function parseUrls(arr) {
+  return arr.map((urlWithHash) => {
+    const parts = urlWithHash.split(FILE_TYPE_DELIM);
+    if (parts.length === 1) {
+      const [url] = parts;
+      return {
+        url,
+        fileType: urlToFileType(url)
+      };
+    }
+    if (parts.length === 2) {
+      const [url, fileType] = parts;
+      return {
+        url,
+        fileType
+      };
+    }
+    throw new Error(`Only expected zero or one ${FILE_TYPE_DELIM} character per URL, but received more.`);
+  });
+}
+function parseUrlsFromString(s) {
+  const urlsWithHashes = s.split(";");
+  return parseUrls(urlsWithHashes);
+}
+async function parsedUrlToZmetadata(parsedUrl) {
+  const { store: initialStore } = parsedUrl;
+  if (!initialStore) {
+    return null;
+  }
+  let store;
+  let promises = [];
+  try {
+    try {
+      store = await withConsolidated(initialStore);
+    } catch {
+      store = await withConsolidated(initialStore, { metadataKey: "zmetadata" });
+    }
+    const contents = store.contents();
+    const consolidatedRoot = await open(store, { kind: "group" });
+    promises = contents.map(async (value) => {
+      let item;
+      try {
+        item = await open(
+          consolidatedRoot.resolve(value.path),
+          { kind: value.kind }
+        );
+      } catch {
+        item = {
+          attrs: {}
+        };
+      }
+      return {
+        ...value,
+        attrs: item.attrs
+      };
+    });
+  } catch {
+    store = initialStore;
+    const keysToTry = [
+      // Note: OME-NGFF metadata is stored in the root attrs.
+      "/",
+      // AnnData keys
+      "/X",
+      "/layers",
+      "/obs",
+      "/var",
+      "/obsm",
+      "/obsm/spatial",
+      "/obsm/X_spatial",
+      "/obsm/pca",
+      "/obsm/X_pca",
+      "/obsm/tsne",
+      "/obsm/X_tsne",
+      "/obsm/umap",
+      "/obsm/X_umap"
+      // TODO: second round of getting metadata for
+      // columns listed in /obs and /var .attrs['column-order'] ?
+      // SpatialData keys
+      // Note: For spatialData, we assume the store is always consolidated.
+      // TODO: throw error if spatialdata + not consolidated?
+    ];
+    const storeRoot = await open(store, { kind: "group" });
+    promises = keysToTry.map(async (k) => {
+      try {
+        const item = await open(storeRoot.resolve(k));
+        return {
+          path: k,
+          kind: item.kind,
+          attrs: item.attrs
+        };
+      } catch {
+        return null;
+      }
+    });
+  }
+  return (await Promise.all(promises)).filter((entry) => entry !== null);
+}
+async function generateConfig(parsedUrls, layoutOption = null) {
+  const parsedStores = ensureStores(parsedUrls);
+  const zmetadataStores = await Promise.all(
+    parsedStores.map(async (parsedStore) => ({
+      ...parsedStore,
+      zmetadata: await parsedUrlToZmetadata(parsedStore)
+    }))
+  );
+  const vc = new VitessceConfig({
+    schemaVersion: "1.0.17",
+    name: "Automatically-generated configuration.",
+    // TODO: write a description based on what is known
+    // (fileType(s) and maybe layoutOption).
+    description: "Populate with a description of this visualization."
+  });
+  const dataset = vc.addDataset("Main dataset");
+  zmetadataStores.forEach((parsedStore) => {
+    const { fileType } = parsedStore;
+    const AutoConfigClass = fileTypeToClass[fileType];
+    const autoConfig = new AutoConfigClass(parsedStore);
+    autoConfig.addFiles(vc, dataset);
+    autoConfig.addViews(vc, dataset, layoutOption);
+  });
+  const stores = Object.fromEntries(
+    // Here, we use `parsedUrls` rather than `parsedStores`
+    // so that we do not provide more stores than intended
+    // (i.e., we do not provide stores which were solely created
+    // to obtain zmetadata).
+    parsedUrls.filter((d) => d.store).map((d) => [d.url, d.store])
+  );
+  return {
+    config: vc,
+    stores
+  };
+}
+export {
+  CL as CoordinationLevel,
+  HINTS_CONFIG,
+  HINT_TYPE_TO_FILE_TYPE_MAP,
+  VitessceConfig,
+  generateConfig$1 as generateConfig,
+  generateConfig as generateConfigAlt,
+  getCoordinationSpaceAndScopes,
+  getHintOptions,
+  getInitialCoordinationScopeName,
+  getInitialCoordinationScopePrefix,
+  hconcat,
+  parseUrls,
+  parseUrlsFromString,
+  vconcat
+};