@vitessce/spatial-utils 4.0.4 → 4.0.6

package/dist/{index-DBZHi0dk.js → index-BScMs9Qo.js}

@@ -6079,8 +6079,8 @@ DimensionError.prototype = new RangeError();
 DimensionError.prototype.constructor = RangeError;
 DimensionError.prototype.name = "DimensionError";
 DimensionError.prototype.isDimensionError = true;
-function IndexError$1(index2, min2, max2) {
-  if (!(this instanceof IndexError$1)) {
+function IndexError(index2, min2, max2) {
+  if (!(this instanceof IndexError)) {
     throw new SyntaxError("Constructor must be called with the new operator");
   }
   this.index = index2;
@@ -6100,10 +6100,10 @@ function IndexError$1(index2, min2, max2) {
   }
   this.stack = new Error().stack;
 }
-IndexError$1.prototype = new RangeError();
-IndexError$1.prototype.constructor = RangeError;
-IndexError$1.prototype.name = "IndexError";
-IndexError$1.prototype.isIndexError = true;
+IndexError.prototype = new RangeError();
+IndexError.prototype.constructor = RangeError;
+IndexError.prototype.name = "IndexError";
+IndexError.prototype.isIndexError = true;
 function arraySize(x) {
   var s2 = [];
   while (Array.isArray(x)) {
@@ -6150,7 +6150,7 @@ function validateIndex(index2, length2) {
     throw new TypeError("Index must be an integer (value: " + index2 + ")");
   }
   if (index2 < 0 || typeof length2 === "number" && index2 >= length2) {
-    throw new IndexError$1(index2, length2);
+    throw new IndexError(index2, length2);
   }
 }
 function resize(array, size2, defaultValue2) {
@@ -43491,9 +43491,9 @@ function getAccessorFromBuffer(typedArray, options) {
     startIndices,
     nested
   } = options;
-  const bytesPerElement = typedArray.BYTES_PER_ELEMENT;
-  const elementStride = stride ? stride / bytesPerElement : size2;
-  const elementOffset = offset ? offset / bytesPerElement : 0;
+  const bytesPerElement2 = typedArray.BYTES_PER_ELEMENT;
+  const elementStride = stride ? stride / bytesPerElement2 : size2;
+  const elementOffset = offset ? offset / bytesPerElement2 : 0;
   const vertexCount = Math.floor((typedArray.length - elementOffset) / elementStride);
   return (_, {
     index: index2,
@@ -52284,9 +52284,9 @@ function getTextFromBuffer({
   startIndices,
   characterSet
 }) {
-  const bytesPerElement = value.BYTES_PER_ELEMENT;
-  const elementStride = stride ? stride / bytesPerElement : 1;
-  const elementOffset = offset ? offset / bytesPerElement : 0;
+  const bytesPerElement2 = value.BYTES_PER_ELEMENT;
+  const elementStride = stride ? stride / bytesPerElement2 : 1;
+  const elementOffset = offset ? offset / bytesPerElement2 : 0;
   const characterCount = startIndices[length2] || Math.ceil((value.length - elementOffset) / elementStride);
   const autoCharacterSet = characterSet && /* @__PURE__ */ new Set();
   const texts = new Array(length2);
@@ -56148,7 +56148,7 @@ function requireLong() {
       var MIN_VALUE = fromBits(0, 2147483648 | 0, false);
       Long2.MIN_VALUE = MIN_VALUE;
       var LongPrototype = Long2.prototype;
-      LongPrototype.toInt = function toInt() {
+      LongPrototype.toInt = function toInt2() {
         return this.unsigned ? this.low >>> 0 : this.low;
       };
       LongPrototype.toNumber = function toNumber2() {
@@ -74230,11 +74230,11 @@ class GLTFPostProcessor {
     }
     return accessor;
   }
-  _getValueFromInterleavedBuffer(buffer, byteOffset, byteStride, bytesPerElement, count2) {
-    const result = new Uint8Array(count2 * bytesPerElement);
+  _getValueFromInterleavedBuffer(buffer, byteOffset, byteStride, bytesPerElement2, count2) {
+    const result = new Uint8Array(count2 * bytesPerElement2);
     for (let i2 = 0; i2 < count2; i2++) {
       const elementOffset = byteOffset + i2 * byteStride;
-      result.set(new Uint8Array(buffer.arrayBuffer.slice(elementOffset, elementOffset + bytesPerElement)), i2 * bytesPerElement);
+      result.set(new Uint8Array(buffer.arrayBuffer.slice(elementOffset, elementOffset + bytesPerElement2)), i2 * bytesPerElement2);
     }
     return result.buffer;
   }
@@ -119129,6 +119129,20 @@ function requireDistEs6() {
 var distEs6Exports$2 = requireDistEs6();
 var distEs6Exports$1 = requireDistEs6$1();
 var distEs6Exports = requireDistEs6$2();
+function runSelectionWithBusySignal(onBusy, work) {
+  if (typeof onBusy !== "function" || typeof requestAnimationFrame !== "function") {
+    work();
+    return;
+  }
+  onBusy(true);
+  requestAnimationFrame(() => setTimeout(() => {
+    try {
+      work();
+    } finally {
+      onBusy(false);
+    }
+  }, 0));
+}
 const EDIT_TYPE_ADD = "addFeature";
 const EDIT_TYPE_CLEAR = "clearFeatures";
 class ClickableDrawPolygonByDraggingMode extends distEs6Exports.DrawPolygonByDraggingMode {
@@ -119143,7 +119157,8 @@ const MODE_MAP = {
 const defaultProps$f = {
   layerIds: [],
   onSelect: () => {
-  }
+  },
+  onSelectionBusy: null
 };
 const EMPTY_DATA = {
   type: "FeatureCollection",
@@ -119235,11 +119250,12 @@ class SelectionLayer extends CompositeLayer {
         selectedFeatureIndexes: [],
         data: EMPTY_DATA,
         onEdit: ({ updatedData, editType }) => {
+          const { onSelectionBusy } = this.props;
           if (editType === EDIT_TYPE_ADD) {
             const { coordinates: coordinates2 } = updatedData.features[0].geometry;
-            this._selectPolygonObjects(coordinates2);
+            runSelectionWithBusySignal(onSelectionBusy, () => this._selectPolygonObjects(coordinates2));
           } else if (editType === EDIT_TYPE_CLEAR) {
-            this._selectEmpty();
+            runSelectionWithBusySignal(onSelectionBusy, () => this._selectEmpty());
           }
         },
         _subLayerProps: {
@@ -120380,22 +120396,22 @@ function addDecoder(cases, importFn) {
   }
   cases.forEach((c) => registry$2.set(c, importFn));
 }
-addDecoder([void 0, 1], () => import("./raw-ChHiLbWA.js").then((m) => m.default));
-addDecoder(5, () => import("./lzw-BqJ_dFlf.js").then((m) => m.default));
+addDecoder([void 0, 1], () => import("./raw-BFsjOa9D.js").then((m) => m.default));
+addDecoder(5, () => import("./lzw-C0hm4LU9.js").then((m) => m.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-D0B2DXrb.js").then((m) => m.default));
-addDecoder([8, 32946], () => import("./deflate-BCZYB9gc.js").then((m) => m.default));
-addDecoder(32773, () => import("./packbits-C3Wqc-kA.js").then((m) => m.default));
+addDecoder(7, () => import("./jpeg-CEsy1aGu.js").then((m) => m.default));
+addDecoder([8, 32946], () => import("./deflate-BpOWypHr.js").then((m) => m.default));
+addDecoder(32773, () => import("./packbits-CkQ8qELh.js").then((m) => m.default));
 addDecoder(
   34887,
-  () => import("./lerc-D1N0v-gZ.js").then(async (m) => {
+  () => import("./lerc-CoY4QzZT.js").then(async (m) => {
     await m.zstd.init();
     return m;
   }).then((m) => m.default)
 );
-addDecoder(50001, () => import("./webimage-Del4KeFH.js").then((m) => m.default));
+addDecoder(50001, () => import("./webimage-C8ngyR6p.js").then((m) => m.default));
 function decodeRowAcc(row, stride) {
   let length2 = row.length - stride;
   let offset = 0;
@@ -129372,7 +129388,7 @@ const COMPRESSORS = /* @__PURE__ */ new Set(["blosclz", "lz4", "lz4hc", "snappy"
 let emscriptenModule;
 const init = () => blosc_codec({ noInitialRun: true, wasmBinary });
 const Blosc = (_a$3 = class {
-  constructor(clevel = 5, cname = "lz4", shuffle = 1, blocksize = 0) {
+  constructor(clevel = 5, cname = "lz4", shuffle2 = 1, blocksize = 0) {
     if (clevel < 0 || clevel > 9) {
       throw new Error(`Invalid compression level: '${clevel}'. It should be between 0 and 9`);
     }
@@ -129380,17 +129396,17 @@ const Blosc = (_a$3 = class {
       throw new Error(`Invalid compressor '${cname}'. Valid compressors include
         'blosclz', 'lz4', 'lz4hc','snappy', 'zlib', 'zstd'.`);
     }
-    if (shuffle < -1 || shuffle > 2) {
-      throw new Error(`Invalid shuffle ${shuffle}. Must be one of 0 (NOSHUFFLE),
+    if (shuffle2 < -1 || shuffle2 > 2) {
+      throw new Error(`Invalid shuffle ${shuffle2}. Must be one of 0 (NOSHUFFLE),
         1 (SHUFFLE), 2 (BITSHUFFLE), -1 (AUTOSHUFFLE).`);
     }
     this.blocksize = blocksize;
     this.clevel = clevel;
     this.cname = cname;
-    this.shuffle = shuffle;
+    this.shuffle = shuffle2;
   }
-  static fromConfig({ blocksize, clevel, cname, shuffle }) {
-    return new _a$3(clevel, cname, shuffle, blocksize);
+  static fromConfig({ blocksize, clevel, cname, shuffle: shuffle2 }) {
+    return new _a$3(clevel, cname, shuffle2, blocksize);
   }
   async encode(data) {
     if (!emscriptenModule) {
@@ -138255,12 +138271,97 @@ function coordinateTransformationsToMatrixForSpatialData(ngffMetadata, targetCoo
   );
   return coordinateTransformationsToMatrix(normalizedTransformations, normAxes);
 }
+class ZarritaError extends Error {
+}
+class NotFoundError extends ZarritaError {
+  constructor(context, options = {}) {
+    super(`Not found: ${context}`, { cause: options.cause });
+    this._tag = "NotFoundError";
+    this.name = "NotFoundError";
+    this.path = options.path;
+    this.found = options.found;
+  }
+}
+class InvalidMetadataError extends ZarritaError {
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this._tag = "InvalidMetadataError";
+    this.name = "InvalidMetadataError";
+    this.path = options.path;
+  }
+}
+class UnknownCodecError extends ZarritaError {
+  constructor(codec) {
+    super(`Unknown codec: ${codec}`);
+    this._tag = "UnknownCodecError";
+    this.name = "UnknownCodecError";
+    this.codec = codec;
+  }
+}
+class CodecPipelineError extends ZarritaError {
+  constructor(options) {
+    const parts = [
+      `Failed to ${options.direction} chunk`,
+      options.codec && `via codec "${options.codec}"`,
+      options.chunkPath && `at ${options.chunkPath}`
+    ].filter(Boolean);
+    super(parts.join(" "), { cause: options.cause });
+    this._tag = "CodecPipelineError";
+    this.name = "CodecPipelineError";
+    this.direction = options.direction;
+    this.codec = options.codec;
+    this.chunkPath = options.chunkPath;
+  }
+}
+class InvalidSelectionError extends ZarritaError {
+  constructor() {
+    super(...arguments);
+    this._tag = "InvalidSelectionError";
+    this.name = "InvalidSelectionError";
+  }
+}
+class UnsupportedError extends ZarritaError {
+  constructor(feature2) {
+    super(`Unsupported: ${feature2}`);
+    this._tag = "UnsupportedError";
+    this.name = "UnsupportedError";
+    this.feature = feature2;
+  }
+}
+function unimplementedEncode(codecName) {
+  return () => {
+    throw new UnsupportedError(`${codecName} encode`);
+  };
+}
+class BitroundCodec {
+  constructor(configuration, _meta) {
+    this.kind = "array_to_array";
+    this.encode = unimplementedEncode("bitround");
+    if (configuration.keepbits < 0) {
+      throw new InvalidMetadataError("keepbits must be zero or positive");
+    }
+  }
+  static fromConfig(configuration, meta) {
+    return new BitroundCodec(configuration, meta);
+  }
+  /**
+   * Decode a chunk of data (no-op).
+   * @param arr - The chunk to decode
+   * @returns The decoded chunk
+   */
+  decode(arr) {
+    return arr;
+  }
+}
+function isArrayBufferLike(x) {
+  return x instanceof ArrayBuffer || x instanceof SharedArrayBuffer;
+}
 class BoolArray {
   #bytes;
   constructor(x, byteOffset, length2) {
     if (typeof x === "number") {
       this.#bytes = new Uint8Array(x);
-    } else if (x instanceof ArrayBuffer) {
+    } else if (isArrayBufferLike(x)) {
       this.#bytes = new Uint8Array(x, byteOffset, length2);
     } else {
       this.#bytes = new Uint8Array(Array.from(x, (v) => v ? 1 : 0));
@@ -138304,7 +138405,7 @@ class ByteStringArray {
     this.#encoder = new TextEncoder();
     if (typeof x === "number") {
       this._data = new Uint8Array(x * chars);
-    } else if (x instanceof ArrayBuffer) {
+    } else if (isArrayBufferLike(x)) {
       if (length2)
         length2 = length2 * chars;
       this._data = new Uint8Array(x, byteOffset, length2);
@@ -138358,7 +138459,7 @@ class UnicodeStringArray {
     this.chars = chars;
     if (typeof x === "number") {
       this.#data = new Int32Array(x * chars);
-    } else if (x instanceof ArrayBuffer) {
+    } else if (isArrayBufferLike(x)) {
       if (length2)
         length2 *= chars;
       this.#data = new Int32Array(x, byteOffset, length2);
@@ -138417,15 +138518,29 @@ class UnicodeStringArray {
     }
   }
 }
-function json_decode_object(bytes) {
+function assertSharedArrayBufferAvailable() {
+  if (typeof SharedArrayBuffer === "undefined") {
+    throw new Error("SharedArrayBuffer is not available. In browsers, this requires Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy headers to be set.");
+  }
+}
+function createBuffer(byteLength, useShared) {
+  {
+    return new SharedArrayBuffer(byteLength);
+  }
+}
+function jsonDecodeObject(bytes) {
   const str = new TextDecoder().decode(bytes);
-  return JSON.parse(str);
+  try {
+    return JSON.parse(str);
+  } catch (cause) {
+    throw new InvalidMetadataError("Failed to decode JSON", { cause });
+  }
 }
-function byteswap_inplace(view, bytes_per_element2) {
-  const numFlips = bytes_per_element2 / 2;
-  const endByteIndex = bytes_per_element2 - 1;
+function byteswapInplace(view, bytesPerElement2) {
+  const numFlips = bytesPerElement2 / 2;
+  const endByteIndex = bytesPerElement2 - 1;
   let t = 0;
-  for (let i2 = 0; i2 < view.length; i2 += bytes_per_element2) {
+  for (let i2 = 0; i2 < view.length; i2 += bytesPerElement2) {
     for (let j = 0; j < numFlips; j += 1) {
       t = view[i2 + j];
       view[i2 + j] = view[i2 + endByteIndex - j];
@@ -138433,16 +138548,16 @@ function byteswap_inplace(view, bytes_per_element2) {
     }
   }
 }
-function get_ctr(data_type) {
-  if (data_type === "v2:object") {
+function getCtr(dataType) {
+  if (dataType === "v2:object") {
     return globalThis.Array;
   }
-  let match = data_type.match(/v2:([US])(\d+)/);
+  let match = dataType.match(/v2:([US])(\d+)/);
   if (match) {
     let [, kind, chars] = match;
     return (kind === "U" ? UnicodeStringArray : ByteStringArray).bind(null, Number(chars));
   }
-  if (data_type === "string") {
+  if (dataType === "string") {
     return globalThis.Array;
   }
   let ctr = {
@@ -138458,11 +138573,13 @@ function get_ctr(data_type) {
     float32: Float32Array,
     float64: Float64Array,
     bool: BoolArray
-  }[data_type];
-  assert$1(ctr, `Unknown or unsupported data_type: ${data_type}`);
+  }[dataType];
+  if (!ctr) {
+    throw new InvalidMetadataError(`Unknown or unsupported dataType: ${dataType}`);
+  }
   return ctr;
 }
-function get_strides(shape, order) {
+function getStrides(shape, order) {
   const rank2 = shape.length;
   if (typeof order === "string") {
     order = order === "C" ? Array.from({ length: rank2 }, (_, i2) => i2) : Array.from({ length: rank2 }, (_, i2) => rank2 - 1 - i2);
@@ -138476,25 +138593,27 @@ function get_strides(shape, order) {
   }
   return stride;
 }
-function create_chunk_key_encoder({ name: name2, configuration }) {
+function createChunkKeyEncoder({ name: name2, configuration }) {
   if (name2 === "default") {
     const separator = configuration?.separator ?? "/";
-    return (chunk_coords) => ["c", ...chunk_coords].join(separator);
+    return (chunkCoords) => ["c", ...chunkCoords].join(separator);
   }
   if (name2 === "v2") {
     const separator = configuration?.separator ?? ".";
-    return (chunk_coords) => chunk_coords.join(separator) || "0";
+    return (chunkCoords) => chunkCoords.join(separator) || "0";
   }
-  throw new Error(`Unknown chunk key encoding: ${name2}`);
+  throw new InvalidMetadataError(`Unknown chunk key encoding: ${name2}`);
 }
-function coerce_dtype(dtype) {
+function coerceDtype(dtype) {
   if (dtype === "|O") {
-    return { data_type: "v2:object" };
+    return { dataType: "v2:object" };
   }
   let match = dtype.match(/^([<|>])(.*)$/);
-  assert$1(match, `Invalid dtype: ${dtype}`);
+  if (!match) {
+    throw new InvalidMetadataError(`Invalid dtype: ${dtype}`);
+  }
   let [, endian, rest] = match;
-  let data_type = {
+  let dataType = {
     b1: "bool",
     i1: "int8",
     u1: "uint8",
@@ -138508,33 +138627,73 @@ function coerce_dtype(dtype) {
     f4: "float32",
     f8: "float64"
   }[rest] ?? (rest.startsWith("S") || rest.startsWith("U") ? `v2:${rest}` : void 0);
-  assert$1(data_type, `Unsupported or unknown dtype: ${dtype}`);
+  if (!dataType) {
+    throw new InvalidMetadataError(`Unsupported or unknown dtype: ${dtype}`);
+  }
   if (endian === "|") {
-    return { data_type };
+    return { dataType };
   }
-  return { data_type, endian: endian === "<" ? "little" : "big" };
+  return { dataType, endian: endian === "<" ? "little" : "big" };
+}
+function isFixedScaleOffsetConfig(filter) {
+  return (filter.id === "fixedscaleoffset" || filter.id === "numcodecs.fixedscaleoffset") && typeof filter.scale === "number" && typeof filter.offset === "number" && (filter.astype === void 0 || typeof filter.astype === "string") && (filter.dtype === void 0 || typeof filter.dtype === "string");
 }
-function v2_to_v3_array_metadata(meta, attributes = {}) {
+function v2ToV3ArrayMetadata(meta, attributes = {}) {
   let codecs = [];
-  let dtype = coerce_dtype(meta.dtype);
+  let dtype = coerceDtype(meta.dtype);
   if (meta.order === "F") {
     codecs.push({ name: "transpose", configuration: { order: "F" } });
   }
+  for (let filter of meta.filters ?? []) {
+    if (filter.id === "fixedscaleoffset" || filter.id === "numcodecs.fixedscaleoffset") {
+      if (!isFixedScaleOffsetConfig(filter)) {
+        throw new InvalidMetadataError(`Invalid fixedscaleoffset filter: ${JSON.stringify(filter)}`);
+      }
+      codecs.push({
+        name: "scale_offset",
+        configuration: {
+          scale: filter.scale,
+          offset: filter.offset
+        }
+      });
+      let astype = filter.astype ?? filter.dtype;
+      if (astype !== void 0 && astype !== meta.dtype) {
+        let castTarget = coerceDtype(astype).dataType;
+        if (!isDataType(castTarget, "number") && !isDataType(castTarget, "bigint")) {
+          throw new InvalidMetadataError(`fixedscaleoffset astype must be a numeric data type, got ${astype}`);
+        }
+        codecs.push({
+          name: "cast_value",
+          configuration: {
+            data_type: castTarget,
+            // `np.around` uses banker's rounding (round-half-to-even).
+            rounding: "nearest-even",
+            // Matches de-facto numpy integer-overflow behavior.
+            out_of_range: "wrap"
+          }
+        });
+      }
+      continue;
+    }
+    let { id, ...configuration } = filter;
+    codecs.push({ name: `numcodecs.${id}`, configuration });
+  }
   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 });
+    codecs.push({ name: `numcodecs.${id}`, configuration });
+  }
+  let dimensionNames;
+  if (globalThis.Array.isArray(attributes._ARRAY_DIMENSIONS)) {
+    dimensionNames = attributes._ARRAY_DIMENSIONS;
   }
   return {
     zarr_format: 3,
     node_type: "array",
     shape: meta.shape,
-    data_type: dtype.data_type,
+    data_type: dtype.dataType,
     chunk_grid: {
       name: "regular",
       configuration: {
@@ -138549,44 +138708,63 @@ function v2_to_v3_array_metadata(meta, attributes = {}) {
     },
     codecs,
     fill_value: meta.fill_value,
+    dimension_names: dimensionNames,
     attributes
   };
 }
-function v2_to_v3_group_metadata(_meta, attributes = {}) {
+function v2ToV3GroupMetadata(_meta, attributes = {}) {
   return {
     zarr_format: 3,
     node_type: "group",
     attributes
   };
 }
-function is_dtype(dtype, query) {
+function isDataType(dtype, query) {
   if (query !== "number" && query !== "bigint" && query !== "boolean" && query !== "object" && query !== "string") {
     return dtype === query;
   }
-  let is_boolean = dtype === "bool";
+  let isBoolean2 = dtype === "bool";
   if (query === "boolean")
-    return is_boolean;
-  let is_string = dtype.startsWith("v2:U") || dtype.startsWith("v2:S") || dtype === "string";
+    return isBoolean2;
+  let isString2 = dtype.startsWith("v2:U") || dtype.startsWith("v2:S") || dtype === "string";
   if (query === "string")
-    return is_string;
-  let is_bigint = dtype === "int64" || dtype === "uint64";
+    return isString2;
+  let isBigint = dtype === "int64" || dtype === "uint64";
   if (query === "bigint")
-    return is_bigint;
-  let is_object = dtype === "v2:object";
+    return isBigint;
+  let isObject2 = dtype === "v2:object";
   if (query === "object")
-    return is_object;
-  return !is_string && !is_bigint && !is_boolean && !is_object;
+    return isObject2;
+  return !isString2 && !isBigint && !isBoolean2 && !isObject2;
 }
-function is_sharding_codec(codec) {
+function isShardingCodec(codec) {
   return codec?.name === "sharding_indexed";
 }
-function ensure_correct_scalar(metadata) {
+function ensureCorrectScalar(metadata) {
   if ((metadata.data_type === "uint64" || metadata.data_type === "int64") && metadata.fill_value != null) {
     return BigInt(metadata.fill_value);
   }
+  let isFloat = metadata.data_type === "float16" || metadata.data_type === "float32" || metadata.data_type === "float64";
+  if (typeof metadata.fill_value === "string" && isFloat) {
+    let mapping = {
+      NaN: NaN,
+      Infinity: Infinity,
+      "-Infinity": -Infinity
+    };
+    if (metadata.fill_value in mapping) {
+      return mapping[metadata.fill_value];
+    }
+  }
   return metadata.fill_value;
 }
-function rethrow_unless(error2, ...errors) {
+function resolveSignal(opts) {
+  let a2 = opts.signal;
+  let b = opts.opts?.signal;
+  if (a2 && b)
+    return AbortSignal.any([a2, b]);
+  return a2 ?? b;
+}
+function rethrowUnless(error2, ...errors) {
   if (!errors.some((ErrorClass) => error2 instanceof ErrorClass)) {
     throw error2;
   }
@@ -138597,7 +138775,13 @@ function assert$1(expression, msg = "") {
   }
 }
 async function decompress(data, { format: format2, signal }) {
-  const response = data instanceof Response ? data : new Response(data);
+  let response;
+  if (data instanceof ArrayBuffer) {
+    response = new Response(data);
+  } else {
+    let bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    response = new Response(bytes.slice().buffer);
+  }
   assert$1(response.body, "Response does not contain body.");
   try {
     const decompressedResponse = new Response(response.body.pipeThrough(new DecompressionStream(format2), { signal }));
@@ -138608,37 +138792,13 @@ async function decompress(data, { format: format2, signal }) {
     throw new Error(`Failed to decode ${format2}`);
   }
 }
-class BitroundCodec {
-  constructor(configuration, _meta) {
-    this.kind = "array_to_array";
-    assert$1(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 LITTLE_ENDIAN_OS = systemIsLittleEndian();
+function systemIsLittleEndian() {
   const a2 = new Uint32Array([305419896]);
   const b = new Uint8Array(a2.buffer, a2.byteOffset, a2.byteLength);
   return !(b[0] === 18);
 }
-function bytes_per_element(TypedArray) {
+function bytesPerElement(TypedArray) {
   if ("BYTES_PER_ELEMENT" in TypedArray) {
     return TypedArray.BYTES_PER_ELEMENT;
   }
@@ -138648,9 +138808,9 @@ class BytesCodec {
   constructor(configuration, meta) {
     this.kind = "array_to_bytes";
     this.#endian = configuration?.endian;
-    this.#TypedArray = get_ctr(meta.data_type);
+    this.#TypedArray = getCtr(meta.dataType);
     this.#shape = meta.shape;
-    this.#stride = get_strides(meta.shape, "C");
+    this.#stride = getStrides(meta.shape, "C");
     const sample = new this.#TypedArray(0);
     this.#BYTES_PER_ELEMENT = sample.BYTES_PER_ELEMENT;
   }
@@ -138665,13 +138825,21 @@ class BytesCodec {
   encode(arr) {
     let bytes = new Uint8Array(arr.data.buffer);
     if (LITTLE_ENDIAN_OS && this.#endian === "big") {
-      byteswap_inplace(bytes, bytes_per_element(this.#TypedArray));
+      bytes = bytes.slice();
+      byteswapInplace(bytes, bytesPerElement(this.#TypedArray));
     }
     return bytes;
   }
+  computeEncodedSize(decodedSize) {
+    return decodedSize;
+  }
   decode(bytes) {
     if (LITTLE_ENDIAN_OS && this.#endian === "big") {
-      byteswap_inplace(bytes, bytes_per_element(this.#TypedArray));
+      bytes = bytes.slice();
+      byteswapInplace(bytes, bytesPerElement(this.#TypedArray));
+    }
+    if (bytes.byteOffset % this.#BYTES_PER_ELEMENT !== 0) {
+      bytes = bytes.slice();
     }
     return {
       data: new this.#TypedArray(bytes.buffer, bytes.byteOffset, bytes.byteLength / this.#BYTES_PER_ELEMENT),
@@ -138680,42 +138848,359 @@ class BytesCodec {
     };
   }
 }
+const SPECIAL_FLOATS = {
+  NaN: NaN,
+  Infinity: Infinity,
+  "-Infinity": -Infinity
+};
+const FLOAT_BYTES = {
+  float16: 2,
+  float32: 4,
+  float64: 8
+};
+function isFloatType(dataType) {
+  return dataType in FLOAT_BYTES;
+}
+function isBigintType(dataType) {
+  return dataType === "int64" || dataType === "uint64";
+}
+function hexToFloat(hex, byteWidth) {
+  const int = BigInt(hex);
+  const buf = new ArrayBuffer(byteWidth);
+  const view = new DataView(buf);
+  if (byteWidth === 2) {
+    if (typeof view.getFloat16 !== "function") {
+      throw new UnsupportedError("float16 hex-encoded scalar decoding (requires DataView.prototype.getFloat16)");
+    }
+    view.setUint16(0, Number(int));
+    return view.getFloat16(0);
+  }
+  if (byteWidth === 4) {
+    view.setUint32(0, Number(int));
+    return view.getFloat32(0);
+  }
+  view.setBigUint64(0, int);
+  return view.getFloat64(0);
+}
+function parseJsonScalar(dataType, value) {
+  if (isBigintType(dataType)) {
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+      throw new InvalidMetadataError(`Expected an integer value for data type "${dataType}", got ${JSON.stringify(value)}`);
+    }
+    return BigInt(value);
+  }
+  if (typeof value === "number") {
+    if (!isFloatType(dataType) && !Number.isInteger(value)) {
+      throw new InvalidMetadataError(`Expected an integer value for data type "${dataType}", got ${value}`);
+    }
+    return value;
+  }
+  if (!isFloatType(dataType)) {
+    throw new InvalidMetadataError(`String-encoded scalar "${value}" is not valid for non-float data type "${dataType}"`);
+  }
+  if (value in SPECIAL_FLOATS) {
+    return SPECIAL_FLOATS[value];
+  }
+  return hexToFloat(value, FLOAT_BYTES[dataType]);
+}
+const SUPPORTED$2 = /* @__PURE__ */ new Set([
+  "int8",
+  "uint8",
+  "int16",
+  "uint16",
+  "int32",
+  "uint32",
+  "int64",
+  "uint64",
+  "float16",
+  "float32",
+  "float64"
+]);
+const INT_BOUNDS = {
+  int8: [-128, 2 ** 7 - 1],
+  uint8: [0, 2 ** 8 - 1],
+  int16: [-32768, 2 ** 15 - 1],
+  uint16: [0, 2 ** 16 - 1],
+  int32: [-2147483648, 2 ** 31 - 1],
+  uint32: [0, 2 ** 32 - 1]
+};
+const BIGINT_BOUNDS = {
+  int64: [-(2n ** 63n), 2n ** 63n - 1n],
+  uint64: [0n, 2n ** 64n - 1n]
+};
+function parseScalarMapEntries(entries, srcType, tgtType) {
+  return entries.map(([src, tgt]) => ({
+    src: parseJsonScalar(srcType, src),
+    tgt: parseJsonScalar(tgtType, tgt)
+  }));
+}
+function scalarMapLookup(value, entries) {
+  for (const entry of entries) {
+    if (typeof entry.src === "number" && Number.isNaN(entry.src)) {
+      if (typeof value === "number" && Number.isNaN(value)) {
+        return entry.tgt;
+      }
+    } else if (value === entry.src) {
+      return entry.tgt;
+    }
+  }
+  return void 0;
+}
+function roundNearestEven(value) {
+  if (!Number.isFinite(value))
+    return value;
+  if (Math.abs(value - Math.trunc(value)) === 0.5) {
+    const floor2 = Math.floor(value);
+    const ceil2 = Math.ceil(value);
+    return floor2 % 2 === 0 ? floor2 : ceil2;
+  }
+  return Math.round(value);
+}
+function nearestAway(value) {
+  return Math.sign(value) * Math.floor(Math.abs(value) + 0.5);
+}
+function getRoundingFn(mode) {
+  switch (mode) {
+    case "nearest-even":
+      return roundNearestEven;
+    case "towards-zero":
+      return Math.trunc;
+    case "towards-positive":
+      return Math.ceil;
+    case "towards-negative":
+      return Math.floor;
+    case "nearest-away":
+      return nearestAway;
+  }
+}
+function makeIntRangeCheck(lo, hi, outOfRange) {
+  const range2 = hi - lo + 1;
+  switch (outOfRange) {
+    case "clamp":
+      return (v) => v < lo ? lo : v > hi ? hi : v;
+    case "wrap":
+      return (v) => v >= lo && v <= hi ? v : ((v - lo) % range2 + range2) % range2 + lo;
+    default:
+      return (v) => {
+        if (v >= lo && v <= hi)
+          return v;
+        throw new Error(`Value ${v} out of range [${lo}, ${hi}]. Set out_of_range='clamp' or out_of_range='wrap' to handle this.`);
+      };
+  }
+}
+function makeBigintRangeCheck(lo, hi, outOfRange) {
+  const range2 = hi - lo + 1n;
+  switch (outOfRange) {
+    case "clamp":
+      return (v) => v < lo ? lo : v > hi ? hi : v;
+    case "wrap":
+      return (v) => v >= lo && v <= hi ? v : ((v - lo) % range2 + range2) % range2 + lo;
+    default:
+      return (v) => {
+        if (v >= lo && v <= hi)
+          return v;
+        throw new Error(`Value ${v} out of range [${lo}, ${hi}]. Set out_of_range='clamp' or out_of_range='wrap' to handle this.`);
+      };
+  }
+}
+class CastValueCodec {
+  constructor(arrayType, encodedType, rounding, outOfRange, decodeMapEntries, encodeMapEntries) {
+    this.kind = "array_to_array";
+    this.encode = unimplementedEncode("cast_value");
+    this.#encodedType = encodedType;
+    this.#arrayTypeCtr = getCtr(arrayType);
+    this.#decodeValue = buildConverter(encodedType, arrayType, rounding, outOfRange, decodeMapEntries);
+    this.#encodeFillValue = buildConverter(arrayType, encodedType, rounding, outOfRange, encodeMapEntries);
+  }
+  #encodedType;
+  #arrayTypeCtr;
+  #decodeValue;
+  #encodeFillValue;
+  /** Return updated metadata reflecting the type and fill value after encoding. */
+  getEncodedMeta(meta) {
+    let fillValue = meta.fillValue;
+    if (fillValue != null) {
+      fillValue = this.#encodeFillValue(fillValue);
+    }
+    return { ...meta, dataType: this.#encodedType, fillValue };
+  }
+  static fromConfig(config3, meta) {
+    const arrayType = meta.dataType;
+    const encodedType = config3.data_type;
+    if (!SUPPORTED$2.has(arrayType)) {
+      throw new InvalidMetadataError(`cast_value codec does not support array data type: ${arrayType}`);
+    }
+    if (!SUPPORTED$2.has(encodedType)) {
+      throw new InvalidMetadataError(`cast_value codec does not support encoded data type: ${encodedType}`);
+    }
+    const rounding = config3.rounding ?? "nearest-even";
+    const decodeMapEntries = config3.scalar_map?.decode ? parseScalarMapEntries(config3.scalar_map.decode, encodedType, arrayType) : [];
+    const encodeMapEntries = config3.scalar_map?.encode ? parseScalarMapEntries(config3.scalar_map.encode, arrayType, encodedType) : [];
+    return new CastValueCodec(arrayType, encodedType, rounding, config3.out_of_range, decodeMapEntries, encodeMapEntries);
+  }
+  decode(chunk) {
+    const input = chunk.data;
+    const out = new this.#arrayTypeCtr(input.length);
+    for (let i2 = 0; i2 < input.length; i2++) {
+      out[i2] = this.#decodeValue(input[i2]);
+    }
+    return { data: out, shape: chunk.shape, stride: chunk.stride };
+  }
+}
+function buildConverter(sourceType, targetType, rounding, outOfRange, mapEntries) {
+  const srcIsFloat = isFloatType(sourceType);
+  const srcIsBigint = isBigintType(sourceType);
+  const dstIsFloat = isFloatType(targetType);
+  const dstIsBigint = isBigintType(targetType);
+  let baseFn;
+  if (srcIsFloat && dstIsFloat) {
+    if (rounding !== "nearest-even") {
+      throw new InvalidMetadataError(`cast_value float -> float only supports "nearest-even" rounding, got "${rounding}"`);
+    }
+    baseFn = (v) => v;
+  } else if (srcIsFloat && !dstIsFloat && !dstIsBigint) {
+    const round2 = getRoundingFn(rounding);
+    const check = makeIntRangeCheck(...INT_BOUNDS[targetType], outOfRange);
+    baseFn = (v) => {
+      if (!Number.isFinite(v)) {
+        throw new Error(`Cannot cast ${v} to integer type without scalar_map`);
+      }
+      return check(round2(v));
+    };
+  } else if (srcIsFloat && dstIsBigint) {
+    const round2 = getRoundingFn(rounding);
+    const check = makeBigintRangeCheck(...BIGINT_BOUNDS[targetType], outOfRange);
+    baseFn = (v) => {
+      if (!Number.isFinite(v)) {
+        throw new Error(`Cannot cast ${v} to integer type without scalar_map`);
+      }
+      return check(BigInt(round2(v)));
+    };
+  } else if (!srcIsFloat && !srcIsBigint && dstIsFloat) {
+    baseFn = (v) => v;
+  } else if (srcIsBigint && dstIsFloat) {
+    baseFn = (v) => Number(v);
+  } else if (!srcIsFloat && !srcIsBigint && !dstIsFloat && !dstIsBigint) {
+    baseFn = makeIntRangeCheck(...INT_BOUNDS[targetType], outOfRange);
+  } else if (!srcIsFloat && !srcIsBigint && dstIsBigint) {
+    const check = makeBigintRangeCheck(...BIGINT_BOUNDS[targetType], outOfRange);
+    baseFn = (v) => check(BigInt(v));
+  } else if (srcIsBigint && !dstIsFloat && !dstIsBigint) {
+    const check = makeIntRangeCheck(...INT_BOUNDS[targetType], outOfRange);
+    baseFn = (v) => check(Number(v));
+  } else if (srcIsBigint && dstIsBigint) {
+    baseFn = makeBigintRangeCheck(...BIGINT_BOUNDS[targetType], outOfRange);
+  } else {
+    throw new Error(`Unhandled type combination: ${sourceType} -> ${targetType}`);
+  }
+  if (mapEntries.length === 0) {
+    return baseFn;
+  }
+  const fn = (v) => {
+    const mapped = scalarMapLookup(v, mapEntries);
+    if (mapped !== void 0)
+      return mapped;
+    return baseFn(v);
+  };
+  return fn;
+}
 class Crc32cCodec {
   constructor() {
     this.kind = "bytes_to_bytes";
+    this.encode = unimplementedEncode("crc32c");
   }
   static fromConfig() {
     return new Crc32cCodec();
   }
-  encode(_) {
-    throw new Error("Not implemented");
-  }
   decode(arr) {
     return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength - 4);
   }
+  computeEncodedSize(decodedSize) {
+    return decodedSize + 4;
+  }
+}
+const SUPPORTED$1 = /* @__PURE__ */ new Set([
+  "int8",
+  "uint8",
+  "int16",
+  "uint16",
+  "int32",
+  "uint32",
+  "int64",
+  "uint64",
+  "float16",
+  "float32",
+  "float64"
+]);
+function assertCOrFContiguous(shape, stride) {
+  const n3 = shape.length;
+  let c = n3 === 0 || stride[n3 - 1] === 1;
+  for (let i2 = n3 - 2; i2 >= 0 && c; i2--) {
+    c = stride[i2] === stride[i2 + 1] * shape[i2 + 1];
+  }
+  if (c)
+    return;
+  let f2 = n3 === 0 || stride[0] === 1;
+  for (let i2 = 1; i2 < n3 && f2; i2++) {
+    f2 = stride[i2] === stride[i2 - 1] * shape[i2 - 1];
+  }
+  if (f2)
+    return;
+  throw new Error(`DeltaCodec requires C- or Fortran-contiguous strides, got shape=${JSON.stringify(shape)} stride=${JSON.stringify(stride)}`);
+}
+class DeltaCodec {
+  constructor(ctr) {
+    this.kind = "array_to_array";
+    this.#ctr = ctr;
+  }
+  #ctr;
+  static fromConfig(_config, meta) {
+    if (!SUPPORTED$1.has(meta.dataType)) {
+      throw new InvalidMetadataError(`Delta codec does not support data type: ${meta.dataType}`);
+    }
+    return new DeltaCodec(getCtr(meta.dataType));
+  }
+  encode(chunk) {
+    assertCOrFContiguous(chunk.shape, chunk.stride);
+    const src = chunk.data;
+    const out = new this.#ctr(src.length);
+    out[0] = src[0];
+    for (let i2 = 1; i2 < src.length; i2++) {
+      out[i2] = src[i2] - src[i2 - 1];
+    }
+    return { data: out, shape: chunk.shape, stride: chunk.stride };
+  }
+  decode(chunk) {
+    assertCOrFContiguous(chunk.shape, chunk.stride);
+    const src = chunk.data;
+    const out = new this.#ctr(src.length);
+    out[0] = src[0];
+    for (let i2 = 1; i2 < src.length; i2++) {
+      out[i2] = out[i2 - 1] + src[i2];
+    }
+    return { data: out, shape: chunk.shape, stride: chunk.stride };
+  }
 }
 class GzipCodec {
   constructor() {
     this.kind = "bytes_to_bytes";
+    this.encode = unimplementedEncode("gzip");
   }
   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) {
+function throwOnNanReplacer(_key, value) {
   assert$1(!Number.isNaN(value), "JsonCodec allow_nan is false but NaN was encountered during encoding.");
   assert$1(value !== Number.POSITIVE_INFINITY, "JsonCodec allow_nan is false but Infinity was encountered during encoding.");
   assert$1(value !== Number.NEGATIVE_INFINITY, "JsonCodec allow_nan is false but -Infinity was encountered during encoding.");
   return value;
 }
-function sort_keys_replacer(_key, value) {
+function sortKeysReplacer(_key, value) {
   return value instanceof Object && !Array.isArray(value) ? Object.keys(value).sort().reduce((sorted, key) => {
     sorted[key] = value[key];
     return sorted;
@@ -138734,7 +139219,7 @@ class JsonCodec {
         separators = [", ", ": "];
       }
     }
-    this.#encoder_config = {
+    this.#encoderConfig = {
       encoding,
       skipkeys,
       ensure_ascii,
@@ -138744,59 +139229,142 @@ class JsonCodec {
       separators,
       sort_keys
     };
-    this.#decoder_config = { strict };
+    this.#decoderConfig = { strict };
   }
-  #encoder_config;
-  #decoder_config;
+  #encoderConfig;
+  #decoderConfig;
   static fromConfig(configuration) {
     return new JsonCodec(configuration);
   }
   encode(buf) {
-    const { indent, encoding, ensure_ascii, check_circular, allow_nan, sort_keys } = this.#encoder_config;
+    const { indent, encoding, ensure_ascii, check_circular, allow_nan, sort_keys } = this.#encoderConfig;
     assert$1(encoding === "utf-8", "JsonCodec does not yet support non-utf-8 encoding.");
-    const replacer_functions = [];
+    const replacerFunctions = [];
     assert$1(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);
+      replacerFunctions.push(throwOnNanReplacer);
     }
     if (sort_keys) {
-      replacer_functions.push(sort_keys_replacer);
+      replacerFunctions.push(sortKeysReplacer);
     }
     const items = Array.from(buf.data);
     items.push("|O");
     items.push(buf.shape);
     let replacer;
-    if (replacer_functions.length) {
+    if (replacerFunctions.length) {
       replacer = (key, value) => {
-        let new_value = value;
-        for (let sub_replacer of replacer_functions) {
-          new_value = sub_replacer(key, new_value);
+        let newValue = value;
+        for (let subReplacer of replacerFunctions) {
+          newValue = subReplacer(key, newValue);
         }
-        return new_value;
+        return newValue;
       };
     }
-    let json_str = JSON.stringify(items, replacer, indent);
+    let jsonStr = 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}`;
+      jsonStr = jsonStr.replace(/[\u007F-\uFFFF]/g, (chr) => {
+        const fullStr = `0000${chr.charCodeAt(0).toString(16)}`;
+        const subStr = fullStr.substring(fullStr.length - 4);
+        return `\\u${subStr}`;
       });
     }
-    return new TextEncoder().encode(json_str);
+    return new TextEncoder().encode(jsonStr);
   }
   decode(bytes) {
-    const { strict } = this.#decoder_config;
+    const { strict } = this.#decoderConfig;
     assert$1(strict, "JsonCodec does not yet support non-strict decoding.");
-    const items = json_decode_object(bytes);
+    const items = jsonDecodeObject(bytes);
     const shape = items.pop();
     items.pop();
     assert$1(shape, "0D not implemented for JsonCodec.");
-    const stride = get_strides(shape, "C");
+    const stride = getStrides(shape, "C");
     const data = items;
     return { data, shape, stride };
   }
 }
+const SUPPORTED = /* @__PURE__ */ new Set([
+  "int8",
+  "uint8",
+  "int16",
+  "uint16",
+  "int32",
+  "uint32",
+  "int64",
+  "uint64",
+  "float16",
+  "float32",
+  "float64"
+]);
+class ScaleOffsetCodec {
+  constructor(scale2, offset, ctr) {
+    this.kind = "array_to_array";
+    this.encode = unimplementedEncode("scale_offset");
+    this.#scale = scale2;
+    this.#offset = offset;
+    this.#ctr = ctr;
+  }
+  #ctr;
+  #scale;
+  #offset;
+  static fromConfig(config3, meta) {
+    if (!SUPPORTED.has(meta.dataType)) {
+      throw new InvalidMetadataError(`scale_offset codec does not support data type: ${meta.dataType}`);
+    }
+    return new ScaleOffsetCodec(parseJsonScalar(meta.dataType, config3.scale ?? 1), parseJsonScalar(meta.dataType, config3.offset ?? 0), getCtr(meta.dataType));
+  }
+  decode(chunk) {
+    const src = chunk.data;
+    const out = new this.#ctr(src.length);
+    for (let i2 = 0; i2 < src.length; i2++) {
+      out[i2] = src[i2] / this.#scale + this.#offset;
+    }
+    return { data: out, shape: chunk.shape, stride: chunk.stride };
+  }
+}
+class ShuffleCodec {
+  constructor(configuration, meta) {
+    this.kind = "bytes_to_bytes";
+    if (meta) {
+      let sample = new (getCtr(meta.dataType))(0);
+      assert$1("BYTES_PER_ELEMENT" in sample, `Shuffle codec requires a fixed-size dtype, got "${meta.dataType}"`);
+      this.#BYTES_PER_ELEMENT = sample.BYTES_PER_ELEMENT;
+    } else {
+      this.#BYTES_PER_ELEMENT = configuration.elementsize ?? 4;
+    }
+  }
+  #BYTES_PER_ELEMENT;
+  static fromConfig(configuration, meta) {
+    return new ShuffleCodec(configuration, meta);
+  }
+  encode(data) {
+    return shuffle(data, this.#BYTES_PER_ELEMENT);
+  }
+  decode(data) {
+    return unshuffle(data, this.#BYTES_PER_ELEMENT);
+  }
+}
+function shuffle(data, elementSize) {
+  let length2 = data.length;
+  let nElements = Math.floor(length2 / elementSize);
+  let result = new Uint8Array(length2);
+  for (let byte = 0; byte < elementSize; byte++) {
+    for (let i2 = 0; i2 < nElements; i2++) {
+      result[byte * nElements + i2] = data[i2 * elementSize + byte];
+    }
+  }
+  return result;
+}
+function unshuffle(data, elementSize) {
+  let length2 = data.length;
+  let nElements = Math.floor(length2 / elementSize);
+  let result = new Uint8Array(length2);
+  for (let byte = 0; byte < elementSize; byte++) {
+    for (let i2 = 0; i2 < nElements; i2++) {
+      result[i2 * elementSize + byte] = data[byte * nElements + i2];
+    }
+  }
+  return result;
+}
 function proxy(arr) {
   if (arr instanceof BoolArray || arr instanceof ByteStringArray || arr instanceof UnicodeStringArray) {
     const arrp = new Proxy(arr, {
@@ -138812,40 +139380,42 @@ function proxy(arr) {
   }
   return arr;
 }
-function empty_like(chunk, order) {
+function emptyLike(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
+    data = new chunk.data.constructor(
+      // @ts-expect-error - the two argument form is not on the shared type
+      chunk.data.chars,
+      chunk.data.length
     );
   } else {
-    data = new chunk.constructor(chunk.data.length);
+    data = new chunk.data.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 size2 = src.data.length;
-  let index2 = Array(n_dims).fill(0);
-  let src_data = proxy(src.data);
-  let out_data = proxy(out.data);
-  for (let src_idx = 0; src_idx < size2; src_idx++) {
-    let out_idx = 0;
-    for (let dim = 0; dim < n_dims; dim++) {
-      out_idx += index2[dim] * out.stride[dim];
-    }
-    out_data[out_idx] = src_data[src_idx];
+    stride: getStrides(chunk.shape, order)
+  };
+}
+function convertArrayOrder(src, target) {
+  let out = emptyLike(src, target);
+  let nDims = src.shape.length;
+  let size2 = src.shape.reduce((a2, b) => a2 * b, 1);
+  let index2 = Array(nDims).fill(0);
+  let srcData = proxy(src.data);
+  let outData = proxy(out.data);
+  for (let n3 = 0; n3 < size2; n3++) {
+    let srcIdx = 0;
+    let outIdx = 0;
+    for (let dim = 0; dim < nDims; dim++) {
+      srcIdx += index2[dim] * src.stride[dim];
+      outIdx += index2[dim] * out.stride[dim];
+    }
+    outData[outIdx] = srcData[srcIdx];
     index2[0] += 1;
-    for (let dim = 0; dim < n_dims; dim++) {
+    for (let dim = 0; dim < nDims; dim++) {
       if (index2[dim] === src.shape[dim]) {
-        if (dim + 1 === n_dims) {
+        if (dim + 1 === nDims) {
           break;
         }
         index2[dim] = 0;
@@ -138855,13 +139425,13 @@ function convert_array_order(src, target) {
   }
   return out;
 }
-function get_order(chunk) {
+function getOrder(chunk) {
   let rank2 = chunk.shape.length;
   assert$1(rank2 === chunk.stride.length, "Shape and stride must have the same length.");
   return chunk.stride.map((s2, i2) => ({ stride: s2, index: i2 })).sort((a2, b) => b.stride - a2.stride).map((entry) => entry.index);
 }
-function matches_order(chunk, target) {
-  let source = get_order(chunk);
+function matchesOrder(chunk, target) {
+  let source = getOrder(chunk);
   assert$1(source.length === target.length, "Orders must match");
   return source.every((dim, i2) => dim === target[i2]);
 }
@@ -138871,70 +139441,64 @@ class TransposeCodec {
     let value = configuration.order ?? "C";
     let rank2 = meta.shape.length;
     let order = new Array(rank2);
-    let inverseOrder = new Array(rank2);
     if (value === "C") {
       for (let i2 = 0; i2 < rank2; ++i2) {
         order[i2] = i2;
-        inverseOrder[i2] = i2;
       }
     } else if (value === "F") {
       for (let i2 = 0; i2 < rank2; ++i2) {
         order[i2] = rank2 - i2 - 1;
-        inverseOrder[i2] = rank2 - i2 - 1;
       }
     } else {
       order = value;
-      order.forEach((x, i2) => {
-        assert$1(inverseOrder[x] === void 0, `Invalid permutation: ${JSON.stringify(value)}`);
-        inverseOrder[x] = i2;
+      let seen = new Array(rank2);
+      order.forEach((x) => {
+        assert$1(!seen[x], `Invalid permutation: ${JSON.stringify(value)}`);
+        seen[x] = true;
       });
     }
     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)) {
+    if (matchesOrder(arr, this.#order)) {
       return arr;
     }
-    return convert_array_order(arr, this.#inverseOrder);
+    return convertArrayOrder(arr, this.#order);
   }
   decode(arr) {
     return {
       data: arr.data,
       shape: arr.shape,
-      stride: get_strides(arr.shape, this.#order)
+      stride: getStrides(arr.shape, this.#order)
     };
   }
 }
 class VLenUTF8 {
   constructor(shape) {
     this.kind = "array_to_bytes";
+    this.encode = unimplementedEncode("vlen-utf8");
     this.#shape = shape;
-    this.#strides = get_strides(shape, "C");
+    this.#strides = getStrides(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 i2 = 0; i2 < data.length; i2++) {
-      let item_length = view.getUint32(pos, true);
+      let itemLength = view.getUint32(pos, true);
       pos += 4;
-      data[i2] = decoder.decode(bytes.buffer.slice(pos, pos + item_length));
-      pos += item_length;
+      data[i2] = decoder.decode(bytes.buffer.slice(pos, pos + itemLength));
+      pos += itemLength;
     }
     return { data, shape: this.#shape, stride: this.#strides };
   }
@@ -138942,130 +139506,175 @@ class VLenUTF8 {
 class ZlibCodec {
   constructor() {
     this.kind = "bytes_to_bytes";
+    this.encode = unimplementedEncode("zlib");
   }
   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);
+function createDefaultRegistry() {
+  let blosc = () => import("./blosc-DvQQ1ST0.js").then((m) => m.default);
+  let lz4 = () => import("./lz4-BIbM36RN.js").then((m) => m.default);
+  let zstd = () => import("./zstd-CO575QiM.js").then((m) => m.default);
+  let gzip2 = () => GzipCodec;
+  let zlib = () => ZlibCodec;
+  return (/* @__PURE__ */ new Map()).set("blosc", blosc).set("lz4", lz4).set("zstd", zstd).set("gzip", gzip2).set("zlib", zlib).set("transpose", () => TransposeCodec).set("bytes", () => BytesCodec).set("crc32c", () => Crc32cCodec).set("vlen-utf8", () => VLenUTF8).set("json2", () => JsonCodec).set("bitround", () => BitroundCodec).set("cast_value", () => CastValueCodec).set("scale_offset", () => ScaleOffsetCodec).set("numcodecs.blosc", blosc).set("numcodecs.lz4", lz4).set("numcodecs.zstd", zstd).set("numcodecs.gzip", gzip2).set("numcodecs.zlib", zlib).set("numcodecs.vlen-utf8", () => VLenUTF8).set("numcodecs.shuffle", () => ShuffleCodec).set("numcodecs.delta", () => DeltaCodec).set("numcodecs.bitround", () => BitroundCodec).set("numcodecs.json2", () => JsonCodec);
 }
-const registry = create_default_registry();
-function create_codec_pipeline(chunk_metadata) {
-  let codecs;
+const registry = createDefaultRegistry();
+function createCodecPipeline(chunkMetadata) {
+  let codecsPromise;
+  function getCodecs() {
+    if (!codecsPromise)
+      codecsPromise = loadCodecs(chunkMetadata);
+    return codecsPromise;
+  }
+  async function runStep(direction, codec, fn) {
+    try {
+      return await fn();
+    } catch (cause) {
+      throw new CodecPipelineError({ direction, codec, cause });
+    }
+  }
   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 codecs = await getCodecs();
+      for (const { name: name2, codec } of codecs.arrayToArray) {
+        chunk = await runStep("encode", name2, () => 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);
+      let bytes = await runStep("encode", codecs.arrayToBytes.name, () => codecs.arrayToBytes.codec.encode(chunk));
+      for (const { name: name2, codec } of codecs.bytesToBytes) {
+        bytes = await runStep("encode", name2, () => codec.encode(bytes));
       }
       return bytes;
     },
     async decode(bytes) {
-      if (!codecs)
-        codecs = await load_codecs(chunk_metadata);
-      for (let i2 = codecs.bytes_to_bytes.length - 1; i2 >= 0; i2--) {
-        bytes = await codecs.bytes_to_bytes[i2].decode(bytes);
+      let codecs = await getCodecs();
+      for (let i2 = codecs.bytesToBytes.length - 1; i2 >= 0; i2--) {
+        const { name: name2, codec } = codecs.bytesToBytes[i2];
+        bytes = await runStep("decode", name2, () => codec.decode(bytes));
       }
-      let chunk = await codecs.array_to_bytes.decode(bytes);
-      for (let i2 = codecs.array_to_array.length - 1; i2 >= 0; i2--) {
-        chunk = await codecs.array_to_array[i2].decode(chunk);
+      let chunk = await runStep("decode", codecs.arrayToBytes.name, () => codecs.arrayToBytes.codec.decode(bytes));
+      for (let i2 = codecs.arrayToArray.length - 1; i2 >= 0; i2--) {
+        const { name: name2, codec } = codecs.arrayToArray[i2];
+        chunk = await runStep("decode", name2, () => codec.decode(chunk));
       }
       return chunk;
+    },
+    async computeEncodedSize(decodedSize) {
+      let codecs = await getCodecs();
+      let size2 = applyEncodedSize(codecs.arrayToBytes.name, codecs.arrayToBytes.codec, decodedSize);
+      for (const { name: name2, codec } of codecs.bytesToBytes) {
+        size2 = applyEncodedSize(name2, codec, size2);
+      }
+      return size2;
     }
   };
 }
-async function load_codecs(chunk_meta) {
-  let promises = chunk_meta.codecs.map(async (meta) => {
+function applyEncodedSize(name2, codec, size2) {
+  if (!codec.computeEncodedSize) {
+    throw new InvalidMetadataError(`Codec "${name2}" cannot compute its encoded size; it is not a fixed-size codec and cannot be used in a sharding index pipeline`);
+  }
+  return codec.computeEncodedSize(size2);
+}
+async function loadCodecs(chunkMeta) {
+  let promises = chunkMeta.codecs.map(async (meta) => {
     let Codec = await registry.get(meta.name)?.();
-    assert$1(Codec, `Unknown codec: ${meta.name}`);
+    if (!Codec) {
+      throw new UnknownCodecError(meta.name);
+    }
     return { Codec, meta };
   });
-  let array_to_array = [];
-  let array_to_bytes;
-  let bytes_to_bytes = [];
+  let arrayToArray = [];
+  let arrayToBytes;
+  let bytesToBytes = [];
+  let currentMeta = { ...chunkMeta };
   for await (let { Codec, meta } of promises) {
-    let codec = Codec.fromConfig(meta.configuration, chunk_meta);
+    let codec = Codec.fromConfig(meta.configuration, currentMeta);
     switch (codec.kind) {
       case "array_to_array":
-        array_to_array.push(codec);
+        arrayToArray.push({
+          name: meta.name,
+          codec
+        });
+        if (codec.getEncodedMeta) {
+          currentMeta = codec.getEncodedMeta(currentMeta);
+        }
         break;
       case "array_to_bytes":
-        array_to_bytes = codec;
+        arrayToBytes = {
+          name: meta.name,
+          codec
+        };
         break;
       default:
-        bytes_to_bytes.push(codec);
+        bytesToBytes.push({
+          name: meta.name,
+          codec
+        });
     }
   }
-  if (!array_to_bytes) {
-    assert$1(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";
+  if (!arrayToBytes) {
+    if (!isTypedArrayLikeMeta(currentMeta)) {
+      throw new InvalidMetadataError(`Cannot encode ${currentMeta.dataType} to bytes without a codec`);
+    }
+    arrayToBytes = {
+      name: "bytes",
+      codec: BytesCodec.fromConfig({ endian: "little" }, currentMeta)
+    };
   }
+  return {
+    arrayToArray,
+    arrayToBytes,
+    bytesToBytes
+  };
 }
-class KeyError extends Error {
-  constructor(path) {
-    super(`Missing key: ${path}`);
-    this.name = "KeyError";
-  }
+function isTypedArrayLikeMeta(meta) {
+  return meta.dataType !== "v2:object" && meta.dataType !== "string";
 }
 const MAX_BIG_UINT = 18446744073709551615n;
-function create_sharded_chunk_getter(location, shard_shape, encode_shard_key, sharding_config) {
-  assert$1(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, i2) => d / sharding_config.chunk_shape[i2]);
-  let index_codec = create_codec_pipeline({
-    data_type: "uint64",
-    shape: [...index_shape, 2],
-    codecs: sharding_config.index_codecs
+function createShardedChunkGetter(location, shardShape, encodeShardKey, shardingConfig) {
+  if (!location.store.getRange) {
+    throw new UnsupportedError("sharding requires a store with getRange");
+  }
+  let getRange = location.store.getRange.bind(location.store);
+  let indexShape = shardShape.map((d, i2) => d / shardingConfig.chunk_shape[i2]);
+  let indexCodec = createCodecPipeline({
+    dataType: "uint64",
+    shape: [...indexShape, 2],
+    codecs: shardingConfig.index_codecs,
+    fillValue: null
   });
+  let rawIndexSize = 16 * indexShape.reduce((a2, b) => a2 * b, 1);
   let cache2 = {};
-  return async (chunk_coord, options) => {
-    let shard_coord = chunk_coord.map((d, i2) => Math.floor(d / index_shape[i2]));
-    let shard_path = location.resolve(encode_shard_key(shard_coord)).path;
-    let index2;
-    if (shard_path in cache2) {
-      index2 = cache2[shard_path];
-    } else {
-      let checksum_size = 4;
-      let index_size = 16 * index_shape.reduce((a2, b) => a2 * b, 1);
-      let bytes = await get_range(shard_path, {
-        suffixLength: index_size + checksum_size
-      }, options);
-      index2 = cache2[shard_path] = bytes ? await index_codec.decode(bytes) : null;
+  return async (chunkCoord, options) => {
+    let shardCoord = chunkCoord.map((d, i2) => Math.floor(d / indexShape[i2]));
+    let shardPath = location.resolve(encodeShardKey(shardCoord)).path;
+    if (!(shardPath in cache2)) {
+      cache2[shardPath] = (async () => {
+        let suffixLength = await indexCodec.computeEncodedSize(rawIndexSize);
+        let bytes = await getRange(shardPath, { suffixLength }, options);
+        return bytes ? await indexCodec.decode(bytes) : null;
+      })().catch((err2) => {
+        delete cache2[shardPath];
+        throw err2;
+      });
     }
+    let index2 = await cache2[shardPath];
     if (index2 === null) {
       return void 0;
     }
     let { data, shape, stride } = index2;
-    let linear_offset = chunk_coord.map((d, i2) => d % shape[i2]).reduce((acc, sel, idx) => acc + sel * stride[idx], 0);
-    let offset = data[linear_offset];
-    let length2 = data[linear_offset + 1];
+    let linearOffset = chunkCoord.map((d, i2) => d % shape[i2]).reduce((acc, sel, idx) => acc + sel * stride[idx], 0);
+    let offset = data[linearOffset];
+    let length2 = data[linearOffset + 1];
     if (offset === MAX_BIG_UINT && length2 === MAX_BIG_UINT) {
       return void 0;
     }
-    return get_range(shard_path, {
+    return getRange(shardPath, {
       offset: Number(offset),
       length: Number(length2)
     }, options);
@@ -139093,55 +139702,63 @@ class Group extends Location {
     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";
+function getArrayOrder(codecs) {
+  const maybeTransposeCodec = codecs.find((c) => c.name === "transpose");
+  return maybeTransposeCodec?.configuration?.order ?? "C";
+}
+function projectOrder(order, axes) {
+  let rank2 = new Map(axes.map((axis, i2) => [axis, i2]));
+  return order.filter((axis) => rank2.has(axis)).map((axis) => rank2.get(axis));
+}
+function makeStrideGetter(nativeOrder) {
+  return (shape, axes) => {
+    let order = globalThis.Array.isArray(nativeOrder) && axes ? projectOrder(nativeOrder, axes) : nativeOrder;
+    return getStrides(shape, order);
+  };
 }
 const CONTEXT_MARKER = Symbol("zarrita.context");
-function get_context(obj) {
+function getContext(obj) {
   return obj[CONTEXT_MARKER];
 }
-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
+function createContext(location, metadata) {
+  let { configuration } = metadata.codecs.find(isShardingCodec) ?? {};
+  let sharedContext = {
+    encodeChunkKey: createChunkKeyEncoder(metadata.chunk_key_encoding),
+    TypedArray: getCtr(metadata.data_type),
+    fillValue: metadata.fill_value
   };
   if (configuration) {
-    let native_order2 = get_array_order(configuration.codecs);
+    let nativeOrder2 = getArrayOrder(configuration.codecs);
     return {
-      ...shared_context,
+      ...sharedContext,
       kind: "sharded",
-      chunk_shape: configuration.chunk_shape,
-      codec: create_codec_pipeline({
-        data_type: metadata.data_type,
+      chunkShape: configuration.chunk_shape,
+      codec: createCodecPipeline({
+        dataType: metadata.data_type,
         shape: configuration.chunk_shape,
-        codecs: configuration.codecs
+        codecs: configuration.codecs,
+        fillValue: metadata.fill_value
       }),
-      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)
+      getStrides: makeStrideGetter(nativeOrder2),
+      getChunkBytes: createShardedChunkGetter(location, metadata.chunk_grid.configuration.chunk_shape, sharedContext.encodeChunkKey, configuration)
     };
   }
-  let native_order = get_array_order(metadata.codecs);
+  let nativeOrder = getArrayOrder(metadata.codecs);
   return {
-    ...shared_context,
+    ...sharedContext,
     kind: "regular",
-    chunk_shape: metadata.chunk_grid.configuration.chunk_shape,
-    codec: create_codec_pipeline({
-      data_type: metadata.data_type,
+    chunkShape: metadata.chunk_grid.configuration.chunk_shape,
+    codec: createCodecPipeline({
+      dataType: metadata.data_type,
       shape: metadata.chunk_grid.configuration.chunk_shape,
-      codecs: metadata.codecs
+      codecs: metadata.codecs,
+      fillValue: metadata.fill_value
     }),
-    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);
+    getStrides: makeStrideGetter(nativeOrder),
+    async getChunkBytes(chunkCoords, options) {
+      let chunkKey = sharedContext.encodeChunkKey(chunkCoords);
+      let chunkPath = location.resolve(chunkKey).path;
+      return location.store.get(chunkPath, options);
     }
   };
 }
@@ -139151,37 +139768,58 @@ let Array$1 = class Array2 extends (_a = Location, _a) {
     this.kind = "array";
     this.#metadata = {
       ...metadata,
-      fill_value: ensure_correct_scalar(metadata)
+      fill_value: ensureCorrectScalar(metadata)
     };
-    this[CONTEXT_MARKER] = create_context(this, metadata);
+    this[CONTEXT_MARKER] = createContext(this, this.#metadata);
   }
   #metadata;
   get attrs() {
     return this.#metadata.attributes;
   }
+  get dimensionNames() {
+    return this.#metadata.dimension_names;
+  }
+  get fillValue() {
+    return this.#metadata.fill_value;
+  }
   get shape() {
     return this.#metadata.shape;
   }
   get chunks() {
-    return this[CONTEXT_MARKER].chunk_shape;
+    return this[CONTEXT_MARKER].chunkShape;
   }
   get dtype() {
     return this.#metadata.data_type;
   }
-  async getChunk(chunk_coords, options) {
+  async getChunk(chunkCoords, options, opts) {
+    if (opts?.useSharedArrayBuffer) {
+      assertSharedArrayBufferAvailable();
+    }
     let context = this[CONTEXT_MARKER];
-    let maybe_bytes = await context.get_chunk_bytes(chunk_coords, options);
-    if (!maybe_bytes) {
-      let size2 = context.chunk_shape.reduce((a2, b) => a2 * b, 1);
-      let data = new context.TypedArray(size2);
-      data.fill(context.fill_value);
+    let maybeBytes = await context.getChunkBytes(chunkCoords, options);
+    if (!maybeBytes) {
+      let size2 = context.chunkShape.reduce((a2, b) => a2 * b, 1);
+      let data;
+      if (opts?.useSharedArrayBuffer) {
+        let sample = new context.TypedArray(0);
+        if (!("BYTES_PER_ELEMENT" in sample)) {
+          console.warn("zarrita: useSharedArrayBuffer is not supported for non-buffer-backed data types.");
+          data = new context.TypedArray(size2);
+        } else {
+          let buffer = createBuffer(size2 * sample.BYTES_PER_ELEMENT);
+          data = new context.TypedArray(buffer, 0, size2);
+        }
+      } else {
+        data = new context.TypedArray(size2);
+      }
+      data.fill(context.fillValue);
       return {
         data,
-        shape: context.chunk_shape,
-        stride: context.get_strides(context.chunk_shape)
+        shape: context.chunkShape,
+        stride: context.getStrides(context.chunkShape)
       };
     }
-    return context.codec.decode(maybe_bytes);
+    return context.codec.decode(maybeBytes);
   }
   /**
    * A helper method to narrow `zarr.Array` Dtype.
@@ -139201,9 +139839,130 @@ let Array$1 = class Array2 extends (_a = Location, _a) {
    * ```
    */
   is(query) {
-    return is_dtype(this.dtype, query);
+    return isDataType(this.dtype, query);
   }
 };
+function applyExtensions(value, extensions) {
+  let result = value;
+  for (let ext of extensions) {
+    if (result instanceof Promise) {
+      result = result.then((v) => ext(v));
+    } else {
+      result = ext(result);
+    }
+  }
+  return result;
+}
+function extendArray(array, ...extensions) {
+  return applyExtensions(array, extensions);
+}
+async function maybeExtend(array) {
+  let exts = array.store.arrayExtensions;
+  if (!exts?.length)
+    return array;
+  let variadic = extendArray;
+  return await variadic(array, ...exts);
+}
+let VERSION_COUNTER = createVersionCounter();
+function createVersionCounter() {
+  let versionCounts = /* @__PURE__ */ new WeakMap();
+  function getCounts(store) {
+    let counts = versionCounts.get(store) ?? { v2: 0, v3: 0 };
+    versionCounts.set(store, counts);
+    return counts;
+  }
+  return {
+    increment(store, version2) {
+      getCounts(store)[version2] += 1;
+    },
+    versionMax(store) {
+      let counts = getCounts(store);
+      return counts.v3 > counts.v2 ? "v3" : "v2";
+    }
+  };
+}
+async function loadAttrs(location, signal) {
+  let metaBytes = await location.store.get(location.resolve(".zattrs").path, {
+    signal
+  });
+  if (!metaBytes)
+    return {};
+  return jsonDecodeObject(metaBytes);
+}
+async function openV2(location, options = {}) {
+  let loc = "store" in location ? location : new Location(location);
+  let { signal } = options;
+  let attrs = {};
+  if (options.attrs ?? true)
+    attrs = await loadAttrs(loc, signal);
+  signal?.throwIfAborted();
+  if (options.kind === "array")
+    return openArrayV2(loc, attrs, signal);
+  if (options.kind === "group")
+    return openGroupV2(loc, attrs, signal);
+  return openArrayV2(loc, attrs, signal).catch((err2) => {
+    rethrowUnless(err2, NotFoundError, InvalidMetadataError);
+    return openGroupV2(loc, attrs, signal);
+  });
+}
+async function openArrayV2(location, attrs, signal) {
+  let { path } = location.resolve(".zarray");
+  let meta = await location.store.get(path, { signal });
+  if (!meta) {
+    throw new NotFoundError("v2 array", { path });
+  }
+  VERSION_COUNTER.increment(location.store, "v2");
+  return maybeExtend(new Array$1(location.store, location.path, v2ToV3ArrayMetadata(jsonDecodeObject(meta), attrs)));
+}
+async function openGroupV2(location, attrs, signal) {
+  let { path } = location.resolve(".zgroup");
+  let meta = await location.store.get(path, { signal });
+  if (!meta) {
+    throw new NotFoundError("v2 group", { path });
+  }
+  VERSION_COUNTER.increment(location.store, "v2");
+  return new Group(location.store, location.path, v2ToV3GroupMetadata(jsonDecodeObject(meta), attrs));
+}
+async function _openV3(location, signal) {
+  let { store, path } = location.resolve("zarr.json");
+  let meta = await location.store.get(path, { signal });
+  if (!meta) {
+    throw new NotFoundError("v3 array or group", { path });
+  }
+  let metaDoc = jsonDecodeObject(meta);
+  if (metaDoc.node_type === "array") {
+    metaDoc.fill_value = ensureCorrectScalar(metaDoc);
+  }
+  return metaDoc.node_type === "array" ? maybeExtend(new Array$1(store, location.path, metaDoc)) : new Group(store, location.path, metaDoc);
+}
+async function openV3(location, options = {}) {
+  let loc = "store" in location ? location : new Location(location);
+  let node2 = await _openV3(loc, options.signal);
+  VERSION_COUNTER.increment(loc.store, "v3");
+  if (options.kind === void 0)
+    return node2;
+  if (options.kind === "array" && node2 instanceof Array$1)
+    return node2;
+  if (options.kind === "group" && node2 instanceof Group)
+    return node2;
+  let kind = node2 instanceof Array$1 ? "array" : "group";
+  throw new NotFoundError(`${options.kind} at ${loc.path}`, {
+    path: loc.path,
+    found: kind
+  });
+}
+async function open(location, options = {}) {
+  let store = "store" in location ? location.store : location;
+  let versionMax = VERSION_COUNTER.versionMax(store);
+  let openPrimary = versionMax === "v2" ? open.v2 : open.v3;
+  let openSecondary = versionMax === "v2" ? open.v3 : open.v2;
+  return openPrimary(location, options).catch((err2) => {
+    rethrowUnless(err2, NotFoundError, InvalidMetadataError);
+    return openSecondary(location, options);
+  });
+}
+open.v2 = openV2;
+open.v3 = openV3;
 function* range(start, stop, step = 1) {
   if (stop === void 0) {
     stop = start;
@@ -139236,15 +139995,15 @@ function* product(...iterables) {
     results[i2] = iterators[i2].next();
   }
 }
-function slice_indices({ start, stop, step }, length2) {
+function sliceIndices({ start, stop, step }, length2) {
   if (step === 0) {
-    throw new Error("slice step cannot be zero");
+    throw new InvalidSelectionError("slice step cannot be zero");
   }
   step = step ?? 1;
-  const step_is_negative = step < 0;
-  const [lower, upper] = step_is_negative ? [-1, length2 - 1] : [0, length2];
+  const stepIsNegative = step < 0;
+  const [lower, upper] = stepIsNegative ? [-1, length2 - 1] : [0, length2];
   if (start === null) {
-    start = step_is_negative ? upper : lower;
+    start = stepIsNegative ? upper : lower;
   } else {
     if (start < 0) {
       start += length2;
@@ -139256,7 +140015,7 @@ function slice_indices({ start, stop, step }, length2) {
     }
   }
   if (stop === null) {
-    stop = step_is_negative ? lower : upper;
+    stop = stepIsNegative ? lower : upper;
   } else {
     if (stop < 0) {
       stop += length2;
@@ -139269,147 +140028,153 @@ function slice_indices({ start, stop, step }, length2) {
   }
   return [start, stop, step];
 }
+function toInt(value) {
+  if (value == null)
+    return null;
+  if (typeof value === "bigint") {
+    if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
+      throw new InvalidSelectionError(`Cannot safely convert ${value} to a number. Value exceeds Number.MAX_SAFE_INTEGER.`);
+    }
+    return Number(value);
+  }
+  return value;
+}
 function slice(start, stop, step = null) {
   if (stop === void 0) {
     stop = start;
     start = null;
   }
   return {
-    start,
-    stop,
-    step
+    start: toInt(start),
+    stop: toInt(stop),
+    step: toInt(step)
   };
 }
-function create_queue() {
+function createQueue() {
   const promises = [];
   return {
     add: (fn) => promises.push(fn()),
     onIdle: () => Promise.all(promises)
   };
 }
-class IndexError extends Error {
-  constructor(msg) {
-    super(msg);
-    this.name = "IndexError";
-  }
+function errTooManyIndices(selection, shape) {
+  throw new InvalidSelectionError(`too many indicies for array; expected ${shape.length}, got ${selection.length}`);
 }
-function err_too_many_indices(selection, shape) {
-  throw new IndexError(`too many indicies for array; expected ${shape.length}, got ${selection.length}`);
+function errBoundscheck(dimLen) {
+  throw new InvalidSelectionError(`index out of bounds for dimension with length ${dimLen}`);
 }
-function err_boundscheck(dim_len) {
-  throw new IndexError(`index out of bounds for dimension with length ${dim_len}`);
+function errNegativeStep() {
+  throw new InvalidSelectionError("only slices with step >= 1 are supported");
 }
-function err_negative_step() {
-  throw new IndexError("only slices with step >= 1 are supported");
-}
-function check_selection_length(selection, shape) {
+function checkSelectionLength(selection, shape) {
   if (selection.length > shape.length) {
-    err_too_many_indices(selection, shape);
+    errTooManyIndices(selection, shape);
   }
 }
-function normalize_integer_selection(dim_sel, dim_len) {
-  dim_sel = Math.trunc(dim_sel);
-  if (dim_sel < 0) {
-    dim_sel = dim_len + dim_sel;
+function normalizeIntegerSelection(dimSel, dimLen) {
+  dimSel = Math.trunc(dimSel);
+  if (dimSel < 0) {
+    dimSel = dimLen + dimSel;
   }
-  if (dim_sel >= dim_len || dim_sel < 0) {
-    err_boundscheck(dim_len);
+  if (dimSel >= dimLen || dimSel < 0) {
+    errBoundscheck(dimLen);
   }
-  return dim_sel;
+  return dimSel;
 }
 class IntDimIndexer {
-  constructor({ dim_sel, dim_len, dim_chunk_len }) {
-    dim_sel = normalize_integer_selection(dim_sel, dim_len);
-    this.dim_sel = dim_sel;
-    this.dim_len = dim_len;
-    this.dim_chunk_len = dim_chunk_len;
+  constructor({ dimSel, dimLen, dimChunkLen }) {
+    dimSel = normalizeIntegerSelection(dimSel, dimLen);
+    this.dimSel = dimSel;
+    this.dimLen = dimLen;
+    this.dimChunkLen = dimChunkLen;
     this.nitems = 1;
   }
   *[Symbol.iterator]() {
-    const dim_chunk_ix = Math.floor(this.dim_sel / this.dim_chunk_len);
-    const dim_offset = dim_chunk_ix * this.dim_chunk_len;
-    const dim_chunk_sel = this.dim_sel - dim_offset;
-    yield { dim_chunk_ix, dim_chunk_sel };
+    const dimChunkIx = Math.floor(this.dimSel / this.dimChunkLen);
+    const dimOffset = dimChunkIx * this.dimChunkLen;
+    const dimChunkSel = this.dimSel - dimOffset;
+    yield { dimChunkIx, dimChunkSel };
   }
 }
 class SliceDimIndexer {
-  constructor({ dim_sel, dim_len, dim_chunk_len }) {
-    const [start, stop, step] = slice_indices(dim_sel, dim_len);
+  constructor({ dimSel, dimLen, dimChunkLen }) {
+    const [start, stop, step] = sliceIndices(dimSel, dimLen);
     this.start = start;
     this.stop = stop;
     this.step = step;
     if (this.step < 1)
-      err_negative_step();
-    this.dim_len = dim_len;
-    this.dim_chunk_len = dim_chunk_len;
+      errNegativeStep();
+    this.dimLen = dimLen;
+    this.dimChunkLen = dimChunkLen;
     this.nitems = Math.max(0, Math.ceil((this.stop - this.start) / this.step));
-    this.nchunks = Math.ceil(this.dim_len / this.dim_chunk_len);
+    this.nchunks = Math.ceil(this.dimLen / this.dimChunkLen);
   }
   *[Symbol.iterator]() {
-    const dim_chunk_ix_from = Math.floor(this.start / this.dim_chunk_len);
-    const dim_chunk_ix_to = Math.ceil(this.stop / this.dim_chunk_len);
-    for (const dim_chunk_ix of range(dim_chunk_ix_from, dim_chunk_ix_to)) {
-      const dim_offset = dim_chunk_ix * this.dim_chunk_len;
-      const dim_limit = Math.min(this.dim_len, (dim_chunk_ix + 1) * this.dim_chunk_len);
-      const dim_chunk_len = dim_limit - dim_offset;
-      let dim_out_offset = 0;
-      let dim_chunk_sel_start = 0;
-      if (this.start < dim_offset) {
-        const remainder = (dim_offset - this.start) % this.step;
+    const dimChunkIx_from = Math.floor(this.start / this.dimChunkLen);
+    const dimChunkIx_to = Math.ceil(this.stop / this.dimChunkLen);
+    for (const dimChunkIx of range(dimChunkIx_from, dimChunkIx_to)) {
+      const dimOffset = dimChunkIx * this.dimChunkLen;
+      const dimLimit = Math.min(this.dimLen, (dimChunkIx + 1) * this.dimChunkLen);
+      const dimChunkLen = dimLimit - dimOffset;
+      let dimOutOffset = 0;
+      let dimChunkSelStart = 0;
+      if (this.start < dimOffset) {
+        const remainder = (dimOffset - this.start) % this.step;
         if (remainder)
-          dim_chunk_sel_start += this.step - remainder;
-        dim_out_offset = Math.ceil((dim_offset - this.start) / this.step);
+          dimChunkSelStart += this.step - remainder;
+        dimOutOffset = Math.ceil((dimOffset - this.start) / this.step);
       } else {
-        dim_chunk_sel_start = this.start - dim_offset;
+        dimChunkSelStart = this.start - dimOffset;
       }
-      const dim_chunk_sel_stop = this.stop > dim_limit ? dim_chunk_len : this.stop - dim_offset;
-      const dim_chunk_sel = [
-        dim_chunk_sel_start,
-        dim_chunk_sel_stop,
+      const dimChunkSelStop = this.stop > dimLimit ? dimChunkLen : this.stop - dimOffset;
+      const dimChunkSel = [
+        dimChunkSelStart,
+        dimChunkSelStop,
         this.step
       ];
-      const dim_chunk_nitems = Math.ceil((dim_chunk_sel_stop - dim_chunk_sel_start) / this.step);
-      const dim_out_sel = [
-        dim_out_offset,
-        dim_out_offset + dim_chunk_nitems,
+      const dimChunkNitems = Math.ceil((dimChunkSelStop - dimChunkSelStart) / this.step);
+      const dimOutSel = [
+        dimOutOffset,
+        dimOutOffset + dimChunkNitems,
         1
       ];
-      yield { dim_chunk_ix, dim_chunk_sel, dim_out_sel };
+      yield { dimChunkIx, dimChunkSel, dimOutSel };
     }
   }
 }
-function normalize_selection(selection, shape) {
+function normalizeSelection(selection, shape) {
   let normalized = [];
   if (selection === null) {
     normalized = shape.map((_) => slice(null));
   } else if (Array.isArray(selection)) {
     normalized = selection.map((s2) => s2 ?? slice(null));
   }
-  check_selection_length(normalized, shape);
+  checkSelectionLength(normalized, shape);
   return normalized;
 }
 class BasicIndexer {
-  constructor({ selection, shape, chunk_shape }) {
-    this.dim_indexers = normalize_selection(selection, shape).map((dim_sel, i2) => {
-      return new (typeof dim_sel === "number" ? IntDimIndexer : SliceDimIndexer)({
+  constructor({ selection, shape, chunkShape }) {
+    this.dimIndexers = normalizeSelection(selection, shape).map((dimSel, i2) => {
+      return new (typeof dimSel === "number" ? IntDimIndexer : SliceDimIndexer)({
         // @ts-expect-error ts inference not strong enough to know correct chunk
-        dim_sel,
-        dim_len: shape[i2],
-        dim_chunk_len: chunk_shape[i2]
+        dimSel,
+        dimLen: shape[i2],
+        dimChunkLen: chunkShape[i2]
       });
     });
-    this.shape = this.dim_indexers.filter((ixr) => ixr instanceof SliceDimIndexer).map((sixr) => sixr.nitems);
+    this.shape = this.dimIndexers.filter((ixr) => ixr instanceof SliceDimIndexer).map((sixr) => sixr.nitems);
+    this.outputAxes = this.dimIndexers.map((ixr, axis) => ({ ixr, axis })).filter(({ ixr }) => ixr instanceof SliceDimIndexer).map(({ axis }) => axis);
   }
   *[Symbol.iterator]() {
-    for (const dim_projections of product(...this.dim_indexers)) {
-      const chunk_coords = dim_projections.map((p) => p.dim_chunk_ix);
-      const mapping = dim_projections.map((p) => {
-        if ("dim_out_sel" in p) {
-          return { from: p.dim_chunk_sel, to: p.dim_out_sel };
+    for (const dimProjections of product(...this.dimIndexers)) {
+      const chunkCoords = dimProjections.map((p) => p.dimChunkIx);
+      const mapping = dimProjections.map((p) => {
+        if ("dimOutSel" in p) {
+          return { from: p.dimChunkSel, to: p.dimOutSel };
         }
-        return { from: p.dim_chunk_sel, to: null };
+        return { from: p.dimChunkSel, to: null };
       });
-      yield { chunk_coords, mapping };
+      yield { chunkCoords, mapping };
     }
   }
 }
@@ -139417,30 +140182,53 @@ function unwrap(arr, idx) {
   return "get" in arr ? arr.get(idx) : arr[idx];
 }
 async function get$1(arr, selection, opts, setter2) {
-  let context = get_context(arr);
+  if (opts.useSharedArrayBuffer) {
+    assertSharedArrayBufferAvailable();
+  }
+  let signal = resolveSignal(opts);
+  let context = getContext(arr);
   let indexer = new BasicIndexer({
     selection,
     shape: arr.shape,
-    chunk_shape: arr.chunks
+    chunkShape: arr.chunks
   });
-  let out = setter2.prepare(new context.TypedArray(indexer.shape.reduce((a2, b) => a2 * b, 1)), indexer.shape, context.get_strides(indexer.shape));
-  let queue = opts.create_queue?.() ?? create_queue();
-  for (const { chunk_coords, mapping } of indexer) {
+  if (arr.shape.length === 0) {
+    let { data: data2 } = await arr.getChunk([], { signal }, { useSharedArrayBuffer: opts.useSharedArrayBuffer });
+    return unwrap(data2, 0);
+  }
+  let size2 = indexer.shape.reduce((a2, b) => a2 * b, 1);
+  let data;
+  if (opts.useSharedArrayBuffer) {
+    let sample = new context.TypedArray(0);
+    if (!("BYTES_PER_ELEMENT" in sample)) {
+      console.warn("zarrita: useSharedArrayBuffer is not supported for non-buffer-backed data types.");
+      data = new context.TypedArray(size2);
+    } else {
+      let buffer = createBuffer(size2 * sample.BYTES_PER_ELEMENT);
+      data = new context.TypedArray(buffer, 0, size2);
+    }
+  } else {
+    data = new context.TypedArray(size2);
+  }
+  let out = setter2.prepare(data, indexer.shape, context.getStrides(indexer.shape, indexer.outputAxes));
+  let queue = opts.createQueue?.() ?? createQueue();
+  for (const { chunkCoords, mapping } of indexer) {
     queue.add(async () => {
-      let { data, shape, stride } = await arr.getChunk(chunk_coords, opts.opts);
-      let chunk = setter2.prepare(data, shape, stride);
-      setter2.set_from_chunk(out, chunk, mapping);
+      signal?.throwIfAborted();
+      let { data: data2, shape, stride } = await arr.getChunk(chunkCoords, { signal }, { useSharedArrayBuffer: opts.useSharedArrayBuffer });
+      let chunk = setter2.prepare(data2, shape, stride);
+      setter2.setFromChunk(out, chunk, mapping);
     });
   }
   await queue.onIdle();
   return indexer.shape.length === 0 ? unwrap(out.data, 0) : out;
 }
-function object_array_view(arr, offset = 0, size2) {
+function objectArrayView(arr, offset = 0, size2) {
   let length2 = size2 ?? arr.length - offset;
   return {
     length: length2,
     subarray(from, to = length2) {
-      return object_array_view(arr, offset + from, to - from);
+      return objectArrayView(arr, offset + from, to - from);
     },
     set(data, start = 0) {
       for (let i2 = 0; i2 < data.length; i2++) {
@@ -139452,32 +140240,32 @@ function object_array_view(arr, offset = 0, size2) {
     }
   };
 }
-function compat_chunk(arr) {
+function compatChunk(arr) {
   if (globalThis.Array.isArray(arr.data)) {
     return {
       // @ts-expect-error
-      data: object_array_view(arr.data),
+      data: objectArrayView(arr.data),
       stride: arr.stride,
-      bytes_per_element: 1
+      bytesPerElement: 1
     };
   }
   return {
     data: new Uint8Array(arr.data.buffer, arr.data.byteOffset, arr.data.byteLength),
     stride: arr.stride,
-    bytes_per_element: arr.data.BYTES_PER_ELEMENT
+    bytesPerElement: arr.data.BYTES_PER_ELEMENT
   };
 }
-function get_typed_array_constructor(arr) {
+function getTypedArrayConstructor(arr) {
   if ("chars" in arr) {
     return arr.constructor.bind(null, arr.chars);
   }
   return arr.constructor;
 }
-function compat_scalar(arr, value) {
+function compatScalar(arr, value) {
   if (globalThis.Array.isArray(arr.data)) {
-    return object_array_view([value]);
+    return objectArrayView([value]);
   }
-  let TypedArray = get_typed_array_constructor(arr.data);
+  let TypedArray = getTypedArrayConstructor(arr.data);
   let data = new TypedArray([value]);
   return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
 }
@@ -139485,19 +140273,19 @@ const setter = {
   prepare(data, shape, stride) {
     return { data, shape, stride };
   },
-  set_scalar(dest, sel, value) {
-    let view = compat_chunk(dest);
-    set_scalar_binary(view, sel, compat_scalar(dest, value), view.bytes_per_element);
+  setScalar(dest, sel, value) {
+    let view = compatChunk(dest);
+    setScalarBinary(view, sel, compatScalar(dest, value), view.bytesPerElement);
   },
-  set_from_chunk(dest, src, projections) {
-    let view = compat_chunk(dest);
-    set_from_chunk_binary(view, compat_chunk(src), view.bytes_per_element, projections);
+  setFromChunk(dest, src, projections) {
+    let view = compatChunk(dest);
+    setFromChunkBinary(view, compatChunk(src), view.bytesPerElement, projections);
   }
 };
 async function get(arr, selection = null, opts = {}) {
   return get$1(arr, selection, opts, setter);
 }
-function indices_len(start, stop, step) {
+function indicesLen(start, stop, step) {
   if (step < 0 && stop < start) {
     return Math.floor((start - stop - 1) / -step) + 1;
   }
@@ -139505,183 +140293,107 @@ function indices_len(start, stop, step) {
     return Math.floor((stop - start - 1) / step) + 1;
   return 0;
 }
-function set_scalar_binary(out, out_selection, value, bytes_per_element2) {
-  if (out_selection.length === 0) {
+function setScalarBinary(out, outSelection, value, bytesPerElement2) {
+  if (outSelection.length === 0) {
     out.data.set(value, 0);
     return;
   }
-  const [slice2, ...slices] = out_selection;
-  const [curr_stride, ...stride] = out.stride;
+  const [slice2, ...slices] = outSelection;
+  const [currStride, ...stride] = out.stride;
   if (typeof slice2 === "number") {
-    const data = out.data.subarray(curr_stride * slice2 * bytes_per_element2);
-    set_scalar_binary({ data, stride }, slices, value, bytes_per_element2);
+    const data = out.data.subarray(currStride * slice2 * bytesPerElement2);
+    setScalarBinary({ data, stride }, slices, value, bytesPerElement2);
     return;
   }
   const [from, to, step] = slice2;
-  const len2 = indices_len(from, to, step);
+  const len2 = indicesLen(from, to, step);
   if (slices.length === 0) {
     for (let i2 = 0; i2 < len2; i2++) {
-      out.data.set(value, curr_stride * (from + step * i2) * bytes_per_element2);
+      out.data.set(value, currStride * (from + step * i2) * bytesPerElement2);
     }
     return;
   }
   for (let i2 = 0; i2 < len2; i2++) {
-    const data = out.data.subarray(curr_stride * (from + step * i2) * bytes_per_element2);
-    set_scalar_binary({ data, stride }, slices, value, bytes_per_element2);
+    const data = out.data.subarray(currStride * (from + step * i2) * bytesPerElement2);
+    setScalarBinary({ data, stride }, slices, value, bytesPerElement2);
   }
 }
-function set_from_chunk_binary(dest, src, bytes_per_element2, projections) {
+function contiguousSpan(projections, destStride, srcStride) {
+  if (projections.length !== destStride.length || projections.length !== srcStride.length) {
+    return null;
+  }
+  let size2 = 1;
+  let destOffset = 0;
+  let srcOffset = 0;
+  for (let i2 = projections.length - 1; i2 >= 0; i2--) {
+    const proj = projections[i2];
+    if (proj.from === null || proj.to === null)
+      return null;
+    if (destStride[i2] !== size2 || srcStride[i2] !== size2)
+      return null;
+    const [from, to, step] = proj.to;
+    const [sfrom, , sstep] = proj.from;
+    if (step !== 1 || sstep !== 1)
+      return null;
+    destOffset += size2 * from;
+    srcOffset += size2 * sfrom;
+    size2 *= indicesLen(from, to, step);
+  }
+  return { size: size2, destOffset, srcOffset };
+}
+function setFromChunkBinary(dest, src, bytesPerElement2, projections) {
+  const span = contiguousSpan(projections, dest.stride, src.stride);
+  if (span !== null) {
+    const offset = span.srcOffset * bytesPerElement2;
+    dest.data.set(src.data.subarray(offset, offset + span.size * bytesPerElement2), span.destOffset * bytesPerElement2);
+    return;
+  }
   const [proj, ...projs] = projections;
   const [dstride, ...dstrides] = dest.stride;
   const [sstride, ...sstrides] = src.stride;
   if (proj.from === null) {
     if (projs.length === 0) {
-      dest.data.set(src.data.subarray(0, bytes_per_element2), proj.to * bytes_per_element2);
+      dest.data.set(src.data.subarray(0, bytesPerElement2), dstride * proj.to * bytesPerElement2);
       return;
     }
-    set_from_chunk_binary({
-      data: dest.data.subarray(dstride * proj.to * bytes_per_element2),
+    setFromChunkBinary({
+      data: dest.data.subarray(dstride * proj.to * bytesPerElement2),
       stride: dstrides
-    }, src, bytes_per_element2, projs);
+    }, src, bytesPerElement2, projs);
     return;
   }
   if (proj.to === null) {
     if (projs.length === 0) {
-      let offset = proj.from * bytes_per_element2;
-      dest.data.set(src.data.subarray(offset, offset + bytes_per_element2), 0);
+      let offset = sstride * proj.from * bytesPerElement2;
+      dest.data.set(src.data.subarray(offset, offset + bytesPerElement2), 0);
       return;
     }
-    set_from_chunk_binary(dest, {
-      data: src.data.subarray(sstride * proj.from * bytes_per_element2),
+    setFromChunkBinary(dest, {
+      data: src.data.subarray(sstride * proj.from * bytesPerElement2),
       stride: sstrides
-    }, bytes_per_element2, projs);
+    }, bytesPerElement2, projs);
     return;
   }
   const [from, to, step] = proj.to;
   const [sfrom, _, sstep] = proj.from;
-  const len2 = indices_len(from, to, step);
+  const len2 = indicesLen(from, to, step);
   if (projs.length === 0) {
-    if (step === 1 && sstep === 1 && dstride === 1 && sstride === 1) {
-      let offset = sfrom * bytes_per_element2;
-      let size2 = len2 * bytes_per_element2;
-      dest.data.set(src.data.subarray(offset, offset + size2), from * bytes_per_element2);
-      return;
-    }
     for (let i2 = 0; i2 < len2; i2++) {
-      let offset = sstride * (sfrom + sstep * i2) * bytes_per_element2;
-      dest.data.set(src.data.subarray(offset, offset + bytes_per_element2), dstride * (from + step * i2) * bytes_per_element2);
+      let offset = sstride * (sfrom + sstep * i2) * bytesPerElement2;
+      dest.data.set(src.data.subarray(offset, offset + bytesPerElement2), dstride * (from + step * i2) * bytesPerElement2);
     }
     return;
   }
   for (let i2 = 0; i2 < len2; i2++) {
-    set_from_chunk_binary({
-      data: dest.data.subarray(dstride * (from + i2 * step) * bytes_per_element2),
+    setFromChunkBinary({
+      data: dest.data.subarray(dstride * (from + i2 * step) * bytesPerElement2),
       stride: dstrides
     }, {
-      data: src.data.subarray(sstride * (sfrom + i2 * sstep) * bytes_per_element2),
+      data: src.data.subarray(sstride * (sfrom + i2 * sstep) * bytesPerElement2),
       stride: sstrides
-    }, bytes_per_element2, projs);
-  }
-}
-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;
+    }, bytesPerElement2, projs);
   }
-  return {
-    increment(store, version2) {
-      get_counts(store)[version2] += 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((err2) => {
-    rethrow_unless(err2, 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 node2 = await _open_v3(loc);
-  VERSION_COUNTER.increment(loc.store, "v3");
-  if (options.kind === void 0)
-    return node2;
-  if (options.kind === "array" && node2 instanceof Array$1)
-    return node2;
-  if (options.kind === "group" && node2 instanceof Group)
-    return node2;
-  let kind = node2 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((err2) => {
-    rethrow_unless(err2, NodeNotFoundError);
-    return open_secondary(location, options);
-  });
 }
-open.v2 = open_v2;
-open.v3 = open_v3;
 function getV2DataType(dtype) {
   const mapping = {
     int8: "|i1",