@vitessce/config 3.8.5 → 3.8.7

package/dist/index.js

@@ -1,6 +1,18 @@
 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"
 };
@@ -28,12 +40,12 @@ var hasRequiredPluralize;
 function requirePluralize() {
   if (hasRequiredPluralize) return pluralize$1.exports;
   hasRequiredPluralize = 1;
-  (function(module, exports) {
-    (function(root, pluralize2) {
+  (function(module2, exports) {
+    (function(root2, pluralize2) {
       if (typeof commonjsRequire === "function" && true && true) {
-        module.exports = pluralize2();
+        module2.exports = pluralize2();
       } else {
-        root.pluralize = pluralize2();
+        root2.pluralize = pluralize2();
       }
     })(pluralize, function() {
       var pluralRules = [];
@@ -430,12 +442,12 @@ var hasRequiredLoglevel;
 function requireLoglevel() {
   if (hasRequiredLoglevel) return loglevel$1.exports;
   hasRequiredLoglevel = 1;
-  (function(module) {
-    (function(root, definition) {
-      if (module.exports) {
-        module.exports = definition();
+  (function(module2) {
+    (function(root2, definition) {
+      if (module2.exports) {
+        module2.exports = definition();
       } else {
-        root.log = definition();
+        root2.log = definition();
       }
     })(loglevel, function() {
       var noop = function() {
@@ -1419,10 +1431,10 @@ class VitessceConfig {
    * @returns {VitessceConfig} A new config instance, with values set to match
    * the config parameter.
    */
-  static fromJSON(config) {
-    const { name, description, version: schemaVersion } = config;
+  static fromJSON(config2) {
+    const { name, description, version: schemaVersion } = config2;
     const vc = new VitessceConfig({ schemaVersion, name, description });
-    config.datasets.forEach((d) => {
+    config2.datasets.forEach((d) => {
       const newDataset = vc.addDataset(d.name, d.description, { uid: d.uid });
       d.files.forEach((f) => {
         newDataset.addFile({
@@ -1433,9 +1445,9 @@ class VitessceConfig {
         });
       });
     });
-    Object.keys(config.coordinationSpace).forEach((cType) => {
+    Object.keys(config2.coordinationSpace).forEach((cType) => {
       if (cType !== CoordinationType.DATASET) {
-        const cObj = config.coordinationSpace[cType];
+        const cObj = config2.coordinationSpace[cType];
         vc.config.coordinationSpace[cType] = {};
         Object.entries(cObj).forEach(([cScopeName, cScopeValue]) => {
           const scope = new VitessceConfigCoordinationScope(cType, cScopeName);
@@ -1444,7 +1456,7 @@ class VitessceConfig {
         });
       }
     });
-    config.layout.forEach((c) => {
+    config2.layout.forEach((c) => {
       const newView = new VitessceConfigView(
         c.component,
         c.coordinationScopes,
@@ -1577,15 +1589,15 @@ const filterViews = (hintsConfig, possibleViews) => {
   }
   return resultViews;
 };
-class AbstractAutoConfig {
+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 {
+};
+class OmeTiffAutoConfig extends AbstractAutoConfig$1 {
   constructor(fileUrl) {
     super();
     this.fileUrl = fileUrl;
@@ -1618,7 +1630,7 @@ class OmeTiffAutoConfig extends AbstractAutoConfig {
     };
   }
 }
-class OmeZarrAutoConfig extends AbstractAutoConfig {
+class OmeZarrAutoConfig extends AbstractAutoConfig$1 {
   constructor(fileUrl) {
     super();
     this.fileUrl = fileUrl;
@@ -1639,7 +1651,7 @@ class OmeZarrAutoConfig extends AbstractAutoConfig {
     };
   }
 }
-class AnndataZarrAutoConfig extends AbstractAutoConfig {
+class AnndataZarrAutoConfig extends AbstractAutoConfig$1 {
   constructor(fileUrl) {
     super();
     this.fileUrl = fileUrl;
@@ -2046,7 +2058,7 @@ function getHintOptions(fileUrls) {
   const datasetType = Object.keys(fileTypes).sort().join(",");
   return HINT_TYPE_TO_FILE_TYPE_MAP?.[datasetType] || [];
 }
-async function generateConfig(fileUrls, hintTitle = null) {
+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.",
@@ -2081,16 +2093,2469 @@ async function generateConfig(fileUrls, hintTitle = null) {
     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(root2, path) {
+  const base = typeof root2 === "string" ? new URL(root2) : root2;
+  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));
+  }
+  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");
+  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";
+}
+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) => {
+    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
+      });
+      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)
+    });
+  };
+}
+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));
+  }
+}
+function root(store) {
+  return new Location(store ?? /* @__PURE__ */ new Map());
+}
+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]))
+  };
+}
+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.info = unzip(reader).then((info) => {
+      if (opts.transformEntries) {
+        info.entries = opts.transformEntries(info.entries);
+      }
+      return info;
+    });
+  }
+  async get(key) {
+    let entry = (await this.info).entries[strip_prefix(key)];
+    if (!entry)
+      return;
+    return new Uint8Array(await entry.arrayBuffer());
+  }
+  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;
+}
+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 firstCoordinateSystem = attrs?.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.obsSpots = {
+          path: relPath,
+          coordinateSystem: firstCoordinateSystem
+        };
+      }
+      if (relPath.match(/^(points)\/([^/]*)$/)) {
+        options.obsPoints = {
+          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,
+          };
+        }
+        const hasObs = tableEls.find((el) => el.path === `${path}/obs`);
+        if (hasObs) {
+          const columnOrder = hasObs.attrs?.["column-order"];
+          options.obsSets = {
+            // region: null,
+            tablePath: relPath,
+            obsSets: columnOrder.map((c) => ({
+              // TODO: determine whether this column is string/categorical.
+              // TODO: determine whether this column contains too many
+              // categories to make sense to consider a cell set.
+              path: `${hasObs.path.substring(1)}/${c}`,
+              name: c
+            }))
+          };
+        }
+      }
+    });
+    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();
+    promises = contents.map(async (value) => {
+      const item = await open(root(store).resolve(value.path));
+      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?
+    ];
+    promises = keysToTry.map(async (k) => {
+      try {
+        const item = await open(root(store).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,
+  generateConfig$1 as generateConfig,
+  generateConfig as generateConfigAlt,
   getCoordinationSpaceAndScopes,
   getHintOptions,
   getInitialCoordinationScopeName,
   getInitialCoordinationScopePrefix,
   hconcat,
+  parseUrls,
+  parseUrlsFromString,
   vconcat
 };