@vitessce/spatial-utils 3.1.2 → 3.2.0

package/dist/{index-551fa504.js → index-ca4e31e3.js}

@@ -62,12 +62,62 @@ function baseGetTag(value) {
 function isObjectLike$1(value) {
   return value != null && typeof value == "object";
 }
+var symbolTag$4 = "[object Symbol]";
+function isSymbol$1(value) {
+  return typeof value == "symbol" || isObjectLike$1(value) && baseGetTag(value) == symbolTag$4;
+}
 var isArray$4 = Array.isArray;
 const isArray$5 = isArray$4;
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+  var index2 = string.length;
+  while (index2-- && reWhitespace.test(string.charAt(index2))) {
+  }
+  return index2;
+}
+var reTrimStart = /^\s+/;
+function baseTrim(string) {
+  return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+}
 function isObject$5(value) {
   var type = typeof value;
   return value != null && (type == "object" || type == "function");
 }
+var NAN$1 = 0 / 0;
+var reIsBadHex$1 = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary$1 = /^0b[01]+$/i;
+var reIsOctal$1 = /^0o[0-7]+$/i;
+var freeParseInt$1 = parseInt;
+function toNumber$3(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol$1(value)) {
+    return NAN$1;
+  }
+  if (isObject$5(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject$5(other) ? other + "" : other;
+  }
+  if (typeof value != "string") {
+    return value === 0 ? value : +value;
+  }
+  value = baseTrim(value);
+  var isBinary2 = reIsBinary$1.test(value);
+  return isBinary2 || reIsOctal$1.test(value) ? freeParseInt$1(value.slice(2), isBinary2 ? 2 : 8) : reIsBadHex$1.test(value) ? NAN$1 : +value;
+}
+var INFINITY = 1 / 0, MAX_INTEGER = 17976931348623157e292;
+function toFinite(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber$3(value);
+  if (value === INFINITY || value === -INFINITY) {
+    var sign2 = value < 0 ? -1 : 1;
+    return sign2 * MAX_INTEGER;
+  }
+  return value === value ? value : 0;
+}
 var asyncTag = "[object AsyncFunction]", funcTag$2 = "[object Function]", genTag$1 = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
 function isFunction$3(value) {
   if (!isObject$5(value)) {
@@ -223,6 +273,16 @@ function isLength(value) {
 function isArrayLike(value) {
   return value != null && isLength(value.length) && !isFunction$3(value);
 }
+function isIterateeCall(value, index2, object2) {
+  if (!isObject$5(object2)) {
+    return false;
+  }
+  var type = typeof index2;
+  if (type == "number" ? isArrayLike(object2) && isIndex$1(index2, object2.length) : type == "string" && index2 in object2) {
+    return eq$4(object2[index2], value);
+  }
+  return false;
+}
 var objectProto$b = Object.prototype;
 function isPrototype(value) {
   var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$b;
@@ -1045,6 +1105,33 @@ function baseIsEqual(value, other, bitmask, customizer, stack2) {
 function isEqual$1(value, other) {
   return baseIsEqual(value, other);
 }
+var nativeCeil = Math.ceil, nativeMax$1 = Math.max;
+function baseRange(start, end, step, fromRight) {
+  var index2 = -1, length2 = nativeMax$1(nativeCeil((end - start) / (step || 1)), 0), result = Array(length2);
+  while (length2--) {
+    result[fromRight ? length2 : ++index2] = start;
+    start += step;
+  }
+  return result;
+}
+function createRange(fromRight) {
+  return function(start, end, step) {
+    if (step && typeof step != "number" && isIterateeCall(start, end, step)) {
+      end = step = void 0;
+    }
+    start = toFinite(start);
+    if (end === void 0) {
+      end = start;
+      start = 0;
+    } else {
+      end = toFinite(end);
+    }
+    step = step === void 0 ? start < end ? 1 : -1 : toFinite(step);
+    return baseRange(start, end, step, fromRight);
+  };
+}
+var range$4 = createRange();
+const range$5 = range$4;
 function assert$c(condition, message) {
   if (!condition) {
     throw new Error("math.gl assertion ".concat(message));
@@ -1800,7 +1887,7 @@ function negate(out, a2) {
   out[2] = -a2[2];
   return out;
 }
-function normalize$3(out, a2) {
+function normalize$4(out, a2) {
   var x2 = a2[0];
   var y2 = a2[1];
   var z2 = a2[2];
@@ -3109,7 +3196,7 @@ function squaredLength$1(a2) {
   var w2 = a2[3];
   return x2 * x2 + y2 * y2 + z2 * z2 + w2 * w2;
 }
-function normalize$2(out, a2) {
+function normalize$3(out, a2) {
   var x2 = a2[0];
   var y2 = a2[1];
   var z2 = a2[2];
@@ -3746,7 +3833,7 @@ var dot$2 = dot$3;
 var lerp$1 = lerp$2;
 var length$2 = length$3;
 var squaredLength = squaredLength$1;
-var normalize$1 = normalize$2;
+var normalize$2 = normalize$3;
 var rotationTo = function() {
   var tmpvec3 = create$3();
   var xUnitVec3 = fromValues(1, 0, 0);
@@ -3757,7 +3844,7 @@ var rotationTo = function() {
       cross$1(tmpvec3, xUnitVec3, a2);
       if (len(tmpvec3) < 1e-6)
         cross$1(tmpvec3, yUnitVec3, a2);
-      normalize$3(tmpvec3, tmpvec3);
+      normalize$4(tmpvec3, tmpvec3);
       setAxisAngle(out, tmpvec3, Math.PI);
       return out;
     } else if (dot2 > 0.999999) {
@@ -3772,7 +3859,7 @@ var rotationTo = function() {
       out[1] = tmpvec3[1];
       out[2] = tmpvec3[2];
       out[3] = 1 + dot2;
-      return normalize$1(out, out);
+      return normalize$2(out, out);
     }
   };
 }();
@@ -3798,7 +3885,7 @@ var rotationTo = function() {
     matr[2] = -view[0];
     matr[5] = -view[1];
     matr[8] = -view[2];
-    return normalize$1(out, fromMat3(out, matr));
+    return normalize$2(out, fromMat3(out, matr));
   };
 })();
 const IDENTITY_QUATERNION = [0, 0, 0, 1];
@@ -28415,8 +28502,10 @@ const ViewType$1 = {
   STATUS: "status",
   SCATTERPLOT: "scatterplot",
   SPATIAL: "spatial",
+  SPATIAL_BETA: "spatialBeta",
   HEATMAP: "heatmap",
   LAYER_CONTROLLER: "layerController",
+  LAYER_CONTROLLER_BETA: "layerControllerBeta",
   GENOMIC_PROFILES: "genomicProfiles",
   GATING: "gating",
   FEATURE_LIST: "featureList",
@@ -28428,20 +28517,24 @@ const ViewType$1 = {
 const DataType$2 = {
   OBS_LABELS: "obsLabels",
   OBS_EMBEDDING: "obsEmbedding",
-  OBS_LOCATIONS: "obsLocations",
   OBS_FEATURE_MATRIX: "obsFeatureMatrix",
   OBS_SETS: "obsSets",
   FEATURE_LABELS: "featureLabels",
   IMAGE: "image",
   OBS_SEGMENTATIONS: "obsSegmentations",
   NEIGHBORHOODS: "neighborhoods",
-  GENOMIC_PROFILES: "genomic-profiles"
+  GENOMIC_PROFILES: "genomic-profiles",
+  OBS_SPOTS: "obsSpots",
+  OBS_POINTS: "obsPoints",
+  OBS_LOCATIONS: "obsLocations"
 };
 const FileType$1 = {
   // Joint file types
   ANNDATA_ZARR: "anndata.zarr",
   // Atomic file types
   OBS_EMBEDDING_CSV: "obsEmbedding.csv",
+  OBS_SPOTS_CSV: "obsSpots.csv",
+  OBS_POINTS_CSV: "obsPoints.csv",
   OBS_LOCATIONS_CSV: "obsLocations.csv",
   OBS_LABELS_CSV: "obsLabels.csv",
   FEATURE_LABELS_CSV: "featureLabels.csv",
@@ -28454,6 +28547,8 @@ const FileType$1 = {
   OBS_FEATURE_MATRIX_ANNDATA_ZARR: "obsFeatureMatrix.anndata.zarr",
   OBS_SETS_ANNDATA_ZARR: "obsSets.anndata.zarr",
   OBS_EMBEDDING_ANNDATA_ZARR: "obsEmbedding.anndata.zarr",
+  OBS_SPOTS_ANNDATA_ZARR: "obsSpots.anndata.zarr",
+  OBS_POINTS_ANNDATA_ZARR: "obsPoints.anndata.zarr",
   OBS_LOCATIONS_ANNDATA_ZARR: "obsLocations.anndata.zarr",
   OBS_SEGMENTATIONS_ANNDATA_ZARR: "obsSegmentations.anndata.zarr",
   OBS_LABELS_ANNDATA_ZARR: "obsLabels.anndata.zarr",
@@ -28462,6 +28557,8 @@ const FileType$1 = {
   OBS_FEATURE_MATRIX_MUDATA_ZARR: "obsFeatureMatrix.mudata.zarr",
   OBS_SETS_MUDATA_ZARR: "obsSets.mudata.zarr",
   OBS_EMBEDDING_MUDATA_ZARR: "obsEmbedding.mudata.zarr",
+  OBS_SPOTS_MUDATA_ZARR: "obsSpots.mudata.zarr",
+  OBS_POINTS_MUDATA_ZARR: "obsPoints.mudata.zarr",
   OBS_LOCATIONS_MUDATA_ZARR: "obsLocations.mudata.zarr",
   OBS_SEGMENTATIONS_MUDATA_ZARR: "obsSegmentations.mudata.zarr",
   OBS_LABELS_MUDATA_ZARR: "obsLabels.mudata.zarr",
@@ -28505,10 +28602,8 @@ const FileType$1 = {
   ANNDATA_EXPRESSION_MATRIX_ZARR: "anndata-expression-matrix.zarr"
 };
 const CoordinationType$1 = {
-  // Meta coordination scopes
   META_COORDINATION_SCOPES: "metaCoordinationScopes",
   META_COORDINATION_SCOPES_BY: "metaCoordinationScopesBy",
-  // Other coordination scopes
   DATASET: "dataset",
   // Entity types
   OBS_TYPE: "obsType",
@@ -28534,6 +28629,7 @@ const CoordinationType$1 = {
   SPATIAL_TARGET_X: "spatialTargetX",
   SPATIAL_TARGET_Y: "spatialTargetY",
   SPATIAL_TARGET_Z: "spatialTargetZ",
+  SPATIAL_TARGET_T: "spatialTargetT",
   SPATIAL_ROTATION_X: "spatialRotationX",
   SPATIAL_ROTATION_Y: "spatialRotationY",
   SPATIAL_ROTATION_Z: "spatialRotationZ",
@@ -28571,7 +28667,46 @@ const CoordinationType$1 = {
   GATING_FEATURE_SELECTION_X: "gatingFeatureSelectionX",
   GATING_FEATURE_SELECTION_Y: "gatingFeatureSelectionY",
   FEATURE_VALUE_TRANSFORM_COEFFICIENT: "featureValueTransformCoefficient",
-  TOOLTIPS_VISIBLE: "tooltipsVisible"
+  TOOLTIPS_VISIBLE: "tooltipsVisible",
+  FILE_UID: "fileUid",
+  IMAGE_LAYER: "imageLayer",
+  IMAGE_CHANNEL: "imageChannel",
+  SEGMENTATION_LAYER: "segmentationLayer",
+  SEGMENTATION_CHANNEL: "segmentationChannel",
+  SPATIAL_TARGET_C: "spatialTargetC",
+  SPATIAL_LAYER_VISIBLE: "spatialLayerVisible",
+  SPATIAL_LAYER_OPACITY: "spatialLayerOpacity",
+  SPATIAL_LAYER_COLORMAP: "spatialLayerColormap",
+  SPATIAL_LAYER_TRANSPARENT_COLOR: "spatialLayerTransparentColor",
+  SPATIAL_LAYER_MODEL_MATRIX: "spatialLayerModelMatrix",
+  SPATIAL_SEGMENTATION_FILLED: "spatialSegmentationFilled",
+  SPATIAL_SEGMENTATION_STROKE_WIDTH: "spatialSegmentationStrokeWidth",
+  SPATIAL_CHANNEL_COLOR: "spatialChannelColor",
+  SPATIAL_CHANNEL_VISIBLE: "spatialChannelVisible",
+  SPATIAL_CHANNEL_OPACITY: "spatialChannelOpacity",
+  SPATIAL_CHANNEL_WINDOW: "spatialChannelWindow",
+  PHOTOMETRIC_INTERPRETATION: "photometricInterpretation",
+  // For 3D volume rendering
+  SPATIAL_RENDERING_MODE: "spatialRenderingMode",
+  VOLUMETRIC_RENDERING_ALGORITHM: "volumetricRenderingAlgorithm",
+  SPATIAL_TARGET_RESOLUTION: "spatialTargetResolution",
+  // For clipping plane sliders
+  SPATIAL_SLICE_X: "spatialSliceX",
+  SPATIAL_SLICE_Y: "spatialSliceY",
+  SPATIAL_SLICE_Z: "spatialSliceZ",
+  // For spatial spot and point layers
+  SPOT_LAYER: "spotLayer",
+  POINT_LAYER: "pointLayer",
+  SPATIAL_SPOT_RADIUS: "spatialSpotRadius",
+  SPATIAL_SPOT_FILLED: "spatialSpotFilled",
+  SPATIAL_SPOT_STROKE_WIDTH: "spatialSpotStrokeWidth",
+  SPATIAL_LAYER_COLOR: "spatialLayerColor",
+  PIXEL_HIGHLIGHT: "pixelHighlight",
+  TOOLTIP_CROSSHAIRS_VISIBLE: "tooltipCrosshairsVisible",
+  LEGEND_VISIBLE: "legendVisible",
+  SPATIAL_CHANNEL_LABELS_VISIBLE: "spatialChannelLabelsVisible",
+  SPATIAL_CHANNEL_LABELS_ORIENTATION: "spatialChannelLabelsOrientation",
+  SPATIAL_CHANNEL_LABEL_SIZE: "spatialChannelLabelSize"
 };
 const ViewType = {
   GENES: [
@@ -28832,6 +28967,8 @@ const annDataObsSets = z.array(z.object({
   ]),
   scorePath: z.string().optional().describe("The location in the AnnData store for the set confidence scores, like 'obs/celltype_prediction_score.'")
 }));
+const annDataObsSpots = annDataObsm;
+const annDataObsPoints = annDataObsm;
 const annDataObsLocations = annDataObsm;
 const annDataObsEmbedding = annDataObsm;
 const annDataObsSegmentations = annDataObs;
@@ -28858,10 +28995,21 @@ z.object({
 z.object({
   obsIndex: z.string(),
   obsEmbedding: z.array(z.string()).length(2)
+  // TODO: support 3D?
+});
+z.object({
+  obsIndex: z.string(),
+  obsSpots: z.array(z.string()).length(2)
+  // TODO: support 3D?
+});
+z.object({
+  obsIndex: z.string(),
+  obsPoints: z.array(z.string()).length(3)
 });
 z.object({
   obsIndex: z.string(),
   obsLocations: z.array(z.string()).length(2)
+  // TODO: support 3D?
 });
 z.object({
   obsIndex: z.string(),
@@ -28893,6 +29041,8 @@ z.object({
   ]),
   obsFeatureMatrix: annDataObsFeatureMatrix,
   obsSets: annDataObsSets,
+  obsSpots: annDataObsSpots,
+  obsPoints: annDataObsPoints,
   obsLocations: annDataObsLocations,
   obsSegmentations: annDataObsSegmentations,
   obsEmbedding: z.union([
@@ -33975,7 +34125,7 @@ var json2csv_umd = { exports: {} };
     var commonjsGlobal$1 = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof self !== "undefined" ? self : {};
     var FUNC_ERROR_TEXT2 = "Expected a function";
     var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
-    var INFINITY = 1 / 0;
+    var INFINITY2 = 1 / 0;
     var funcTag2 = "[object Function]", genTag2 = "[object GeneratorFunction]", symbolTag2 = "[object Symbol]";
     var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/, reLeadingDot = /^\./, rePropName2 = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
     var reRegExpChar2 = /[\\^$.*+?()[\]{}|]/g;
@@ -34158,7 +34308,7 @@ var json2csv_umd = { exports: {} };
         return symbolToString ? symbolToString.call(value) : "";
       }
       var result = value + "";
-      return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+      return result == "0" && 1 / value == -INFINITY2 ? "-0" : result;
     }
     function castPath(value) {
       return isArray$22(value) ? value : stringToPath3(value);
@@ -34204,7 +34354,7 @@ var json2csv_umd = { exports: {} };
         return value;
       }
       var result = value + "";
-      return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+      return result == "0" && 1 / value == -INFINITY2 ? "-0" : result;
     }
     function toSource2(func) {
       if (func != null) {
@@ -36829,17 +36979,17 @@ let COLOR;
   COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
   COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
 })(COLOR || (COLOR = {}));
-function getColor(color) {
+function getColor$1(color) {
   return typeof color === "string" ? COLOR[color.toUpperCase()] || COLOR.WHITE : color;
 }
 function addColor(string, color, background) {
   if (!isBrowser$1 && typeof string === "string") {
     if (color) {
-      color = getColor(color);
+      color = getColor$1(color);
       string = "\x1B[".concat(color, "m").concat(string, "\x1B[39m");
     }
     if (background) {
-      color = getColor(background);
+      color = getColor$1(background);
       string = "\x1B[".concat(background + 10, "m").concat(string, "\x1B[49m");
     }
   }
@@ -66949,7 +67099,7 @@ function copyFlatRing(target, targetStartIndex, positions, size2, srcStartIndex
   modifyPolygonWindingDirection(target, windingDirection, windingOptions);
   return targetIndex;
 }
-function normalize(polygon2, positionSize) {
+function normalize$1(polygon2, positionSize) {
   validate(polygon2);
   const positions = [];
   const holeIndices = [];
@@ -67055,7 +67205,7 @@ class PolygonTesselator extends Tesselator {
   }
   normalizeGeometry(polygon2) {
     if (this.normalize) {
-      const normalizedPolygon = normalize(polygon2, this.positionSize);
+      const normalizedPolygon = normalize$1(polygon2, this.positionSize);
       if (this.opts.resolution) {
         return cutPolygonByGrid(getPositions(normalizedPolygon), getHoleIndices(normalizedPolygon), {
           size: this.positionSize,
@@ -67677,7 +67827,7 @@ class PolygonLayer extends CompositeLayer {
       objectInfo.index++;
       let polygon2 = getPolygon(object2, objectInfo);
       if (_normalize) {
-        polygon2 = normalize(polygon2, positionSize);
+        polygon2 = normalize$1(polygon2, positionSize);
       }
       const {
         holeIndices
@@ -111504,7 +111654,7 @@ function clipExtent(x02, y02, x12, y12) {
     return clipStream;
   };
 }
-function extent() {
+function extent$1() {
   var x02 = 0, y02 = 0, x12 = 960, y12 = 500, cache2, cacheStream, clip2;
   return clip2 = {
     stream: function(stream) {
@@ -112911,7 +113061,7 @@ const d3Geo$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   geoBounds: bounds,
   geoCentroid: centroid$3,
   geoCircle: circle$2,
-  geoClipExtent: extent,
+  geoClipExtent: extent$1,
   geoConicConformal: conicConformal,
   geoConicConformalRaw: conicConformalRaw,
   geoConicEqualArea: conicEqualArea,
@@ -132114,28 +132264,38 @@ const PASS_THROUGH_PROPS = [
 ];
 class SelectionLayer extends CompositeLayer {
   _selectPolygonObjects(coordinates2) {
-    const { onSelect, getCellCoords, cellsQuadTree, flipY } = this.props;
+    const { flipY, obsLayers } = this.props;
     const flippedCoordinates = flipY ? coordinates2.map((poly) => poly.map((p) => [p[0], -p[1]])) : coordinates2;
     const selectedPolygon = polygon(flippedCoordinates);
-    const pickingInfos = [];
-    cellsQuadTree.visit((node2, x02, y02, x12, y12) => {
-      const nodePoints = [[[x02, y02], [x12, y02], [x12, y12], [x02, y12], [x02, y02]]];
-      const nodePolygon = polygon(nodePoints);
-      const nodePolygonContainsSelectedPolygon = booleanContains(nodePolygon, selectedPolygon);
-      const nodePolygonWithinSelectedPolygon = booleanWithin(nodePolygon, selectedPolygon);
-      const nodePolygonOverlapsSelectedPolgyon = booleanOverlap(nodePolygon, selectedPolygon);
-      if (!nodePolygonContainsSelectedPolygon && !nodePolygonWithinSelectedPolygon && !nodePolygonOverlapsSelectedPolgyon) {
-        return true;
-      }
-      if (node2.data && booleanPointInPolygon$1(point([].slice.call(getCellCoords(node2.data))), selectedPolygon)) {
-        pickingInfos.push(node2.data);
-      }
-      return false;
+    obsLayers.forEach((obsLayer) => {
+      const { getObsCoords, obsQuadTree, obsIndex, onSelect: layerOnSelect } = obsLayer;
+      const pickingInfos = [];
+      obsQuadTree == null ? void 0 : obsQuadTree.visit((node2, x02, y02, x12, y12) => {
+        const nodePoints = [[[x02, y02], [x12, y02], [x12, y12], [x02, y12], [x02, y02]]];
+        const nodePolygon = polygon(nodePoints);
+        const nodePolygonContainsSelectedPolygon = booleanContains(nodePolygon, selectedPolygon);
+        const nodePolygonWithinSelectedPolygon = booleanWithin(nodePolygon, selectedPolygon);
+        const nodePolygonOverlapsSelectedPolgyon = booleanOverlap(nodePolygon, selectedPolygon);
+        if (!nodePolygonContainsSelectedPolygon && !nodePolygonWithinSelectedPolygon && !nodePolygonOverlapsSelectedPolgyon) {
+          return true;
+        }
+        if (node2.data && booleanPointInPolygon$1(point([].slice.call(getObsCoords(node2.data))), selectedPolygon)) {
+          pickingInfos.push(node2.data);
+        }
+        return false;
+      });
+      const pickingIds = pickingInfos.map((obsI) => obsIndex[obsI]);
+      layerOnSelect(pickingIds);
+    });
+  }
+  _selectEmpty() {
+    const { obsLayers } = this.props;
+    obsLayers.forEach((obsLayer) => {
+      const { onSelect: layerOnSelect } = obsLayer;
+      layerOnSelect([]);
     });
-    onSelect({ pickingInfos });
   }
   renderLayers() {
-    const { onSelect } = this.props;
     const mode = MODE_MAP[this.props.selectionType] || distEs6.ViewMode;
     const inheritedProps = {};
     PASS_THROUGH_PROPS.forEach((p) => {
@@ -132157,7 +132317,7 @@ class SelectionLayer extends CompositeLayer {
             const { coordinates: coordinates2 } = updatedData.features[0].geometry;
             this._selectPolygonObjects(coordinates2);
           } else if (editType === EDIT_TYPE_CLEAR) {
-            onSelect({ pickingInfos: [] });
+            this._selectEmpty();
           }
         },
         _subLayerProps: {
@@ -133297,16 +133457,16 @@ function addDecoder(cases, importFn) {
   }
   cases.forEach((c) => registry$1.set(c, importFn));
 }
-addDecoder([void 0, 1], () => import("./raw-8e22b1c4.js").then((m) => m.default));
-addDecoder(5, () => import("./lzw-c3783269.js").then((m) => m.default));
+addDecoder([void 0, 1], () => import("./raw-446b6beb.js").then((m) => m.default));
+addDecoder(5, () => import("./lzw-c5e8dff0.js").then((m) => m.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-d67d9d82.js").then((m) => m.default));
-addDecoder([8, 32946], () => import("./deflate-6fd0bca9.js").then((m) => m.default));
-addDecoder(32773, () => import("./packbits-209c03d7.js").then((m) => m.default));
-addDecoder(34887, () => import("./lerc-522345a3.js").then((m) => m.default));
-addDecoder(50001, () => import("./webimage-a5d2769c.js").then((m) => m.default));
+addDecoder(7, () => import("./jpeg-76bff48f.js").then((m) => m.default));
+addDecoder([8, 32946], () => import("./deflate-3240dc7e.js").then((m) => m.default));
+addDecoder(32773, () => import("./packbits-ccf26149.js").then((m) => m.default));
+addDecoder(34887, () => import("./lerc-1ad8fc7c.js").then((m) => m.default));
+addDecoder(50001, () => import("./webimage-bf1c5425.js").then((m) => m.default));
 function decodeRowAcc(row, stride) {
   let length2 = row.length - stride;
   let offset = 0;
@@ -140201,7 +140361,7 @@ const SIGNAL_ABORTED = "__vivSignalAborted";
 addDecoder(5, () => LZWDecoder);
 const MAX_COLOR_INTENSITY = 255;
 const DEFAULT_COLOR_OFF = [0, 0, 0];
-const MAX_CHANNELS = 6;
+const MAX_CHANNELS$1 = 6;
 const DEFAULT_FONT_FAMILY = "-apple-system, 'Helvetica Neue', Arial, sans-serif";
 const DTYPE_VALUES = {
   Uint8: {
@@ -141723,7 +141883,7 @@ const AdditiveColormapExtension = class extends LayerExtension {
 };
 AdditiveColormapExtension.extensionName = "AdditiveColormapExtension";
 AdditiveColormapExtension.defaultProps = defaultProps$4$1;
-const fs$1$1 = `uniform vec3 transparentColor;
+const fs$1$2 = `uniform vec3 transparentColor;
 uniform bool useTransparentColor;
 uniform float opacity;
 
@@ -141750,12 +141910,12 @@ rgba = apply_opacity(rgb);
 `;
 const colorPalette = {
   name: "color-palette-module",
-  fs: fs$1$1,
+  fs: fs$1$2,
   inject: {
     "fs:DECKGL_MUTATE_COLOR": DECKGL_MUTATE_COLOR
   }
 };
-function padWithDefault$2(arr, defaultValue2, padWidth) {
+function padWithDefault$3(arr, defaultValue2, padWidth) {
   for (let i2 = 0; i2 < padWidth; i2 += 1) {
     arr.push(defaultValue2);
   }
@@ -141781,8 +141941,8 @@ function padColors({ colors, channelsVisible }) {
   const newColors = colors.map(
     (color, i2) => channelsVisible[i2] ? color.map((c) => c / MAX_COLOR_INTENSITY) : DEFAULT_COLOR_OFF
   );
-  const padSize = MAX_CHANNELS - newColors.length;
-  const paddedColors = padWithDefault$2(
+  const padSize = MAX_CHANNELS$1 - newColors.length;
+  const paddedColors = padWithDefault$3(
     newColors,
     DEFAULT_COLOR_OFF,
     padSize
@@ -142026,7 +142186,7 @@ vec4 colormap(float intensity, float opacity) {
     fs: fs2
   };
 }
-const defaultProps$1$1 = {
+const defaultProps$1$2 = {
   colormap: { type: "string", value: "viridis", compare: true }
 };
 const BaseExtension$1 = class extends LayerExtension {
@@ -142036,7 +142196,7 @@ const BaseExtension$1 = class extends LayerExtension {
   }
   getShaders() {
     var _a2;
-    const name2 = ((_a2 = this == null ? void 0 : this.props) == null ? void 0 : _a2.colormap) || defaultProps$1$1.colormap.value;
+    const name2 = ((_a2 = this == null ? void 0 : this.props) == null ? void 0 : _a2.colormap) || defaultProps$1$2.colormap.value;
     const apply_cmap = cmaps[name2];
     return {
       ...super.getShaders(),
@@ -142055,7 +142215,7 @@ const BaseExtension$1 = class extends LayerExtension {
   }
 };
 BaseExtension$1.extensionName = "BaseExtension";
-BaseExtension$1.defaultProps = defaultProps$1$1;
+BaseExtension$1.defaultProps = defaultProps$1$2;
 const _BEFORE_RENDER$5 = "";
 const _RENDER$5 = `  float intensityArray[6] = float[6](intensityValue0, intensityValue1, intensityValue2, intensityValue3, intensityValue4, intensityValue5);
   float total = 0.0;
@@ -142254,7 +142414,7 @@ const channels = {
 function range(len2) {
   return [...Array(len2).keys()];
 }
-function padWithDefault$1(arr, defaultValue2, padWidth) {
+function padWithDefault$2(arr, defaultValue2, padWidth) {
   for (let i2 = 0; i2 < padWidth; i2 += 1) {
     arr.push(defaultValue2);
   }
@@ -142278,20 +142438,20 @@ function padContrastLimits({
   const newContrastLimits = contrastLimits.map(
     (slider, i2) => channelsVisible[i2] ? slider : [maxSliderValue, maxSliderValue]
   );
-  const padSize = MAX_CHANNELS - newContrastLimits.length;
+  const padSize = MAX_CHANNELS$1 - newContrastLimits.length;
   if (padSize < 0) {
     throw Error(
       `${newContrastLimits.lengths} channels passed in, but only 6 are allowed.`
     );
   }
-  const paddedContrastLimits = padWithDefault$1(
+  const paddedContrastLimits = padWithDefault$2(
     newContrastLimits,
     [maxSliderValue, maxSliderValue],
     padSize
   ).reduce((acc, val) => acc.concat(val), []);
   return paddedContrastLimits;
 }
-function getPhysicalSizeScalingMatrix(loader) {
+function getPhysicalSizeScalingMatrix$1(loader) {
   var _a2;
   const { x: x2, y: y2, z: z2 } = ((_a2 = loader == null ? void 0 : loader.meta) == null ? void 0 : _a2.physicalSizes) ?? {};
   if ((x2 == null ? void 0 : x2.size) && (y2 == null ? void 0 : y2.size) && (z2 == null ? void 0 : z2.size)) {
@@ -142314,7 +142474,7 @@ function makeBoundingBox(viewState) {
     viewport.unproject([0, viewport.height])
   ];
 }
-const fs$1 = `#define SHADER_NAME xr-layer-fragment-shader
+const fs$1$1 = `#define SHADER_NAME xr-layer-fragment-shader
 
 precision highp float;
 precision highp int;
@@ -142355,7 +142515,7 @@ void main() {
   DECKGL_FILTER_COLOR(gl_FragColor, geometry);
 }
 `;
-const vs$1 = `#define SHADER_NAME xr-layer-vertex-shader
+const vs$1$1 = `#define SHADER_NAME xr-layer-vertex-shader
 
 attribute vec2 texCoords;
 attribute vec3 positions;
@@ -142374,7 +142534,7 @@ void main(void) {
   DECKGL_FILTER_COLOR(color, geometry);
 }
 `;
-const coreShaderModule = { fs: fs$1, vs: vs$1 };
+const coreShaderModule = { fs: fs$1$1, vs: vs$1$1 };
 function validateWebGL2Filter(gl, interpolation) {
   const canShowFloat = hasFeature(gl, FEATURES$1.TEXTURE_FLOAT);
   const canShowLinear = hasFeature(gl, FEATURES$1.TEXTURE_FILTER_LINEAR_FLOAT);
@@ -143465,7 +143625,7 @@ const CUBE_STRIP = [
   0
 ];
 const NUM_PLANES_DEFAULT = 1;
-const defaultProps$1 = {
+const defaultProps$1$1 = {
   pickable: false,
   coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
   channelData: { type: "object", value: {}, compare: true },
@@ -143607,7 +143767,7 @@ const XR3DLayer = class extends Layer {
       });
       const invertedScaleMatrix = scaleMatrix.clone().invert();
       const invertedResolutionMatrix = resolutionMatrix.clone().invert();
-      const paddedClippingPlanes = padWithDefault$1(
+      const paddedClippingPlanes = padWithDefault$2(
         clippingPlanes.map(
           (p) => p.clone().transform(invertedScaleMatrix).transform(invertedResolutionMatrix)
         ),
@@ -143697,7 +143857,7 @@ const XR3DLayer = class extends Layer {
   }
 };
 XR3DLayer.layerName = "XR3DLayer";
-XR3DLayer.defaultProps = defaultProps$1;
+XR3DLayer.defaultProps = defaultProps$1$1;
 async function getVolume({
   source,
   selection,
@@ -143845,7 +144005,7 @@ const VolumeLayer = class extends CompositeLayer {
           signal
         })
       );
-      const physicalSizeScalingMatrix = getPhysicalSizeScalingMatrix(
+      const physicalSizeScalingMatrix = getPhysicalSizeScalingMatrix$1(
         loader[resolution]
       );
       Promise.all(volumePromises).then((volumes) => {
@@ -143919,7 +144079,7 @@ const VolumeLayer = class extends CompositeLayer {
 };
 VolumeLayer.layerName = "VolumeLayer";
 VolumeLayer.defaultProps = defaultProps$9;
-const vs = `
+const vs$1 = `
 #define SHADER_NAME bitmask-layer-vertex-shader
 
 attribute vec2 texCoords;
@@ -143940,7 +144100,7 @@ void main(void) {
   DECKGL_FILTER_COLOR(color, geometry);
 }
 `;
-const fs = `
+const fs$1 = `
 #define SHADER_NAME bitmask-layer-fragment-shader
 precision highp float;
 
@@ -144008,14 +144168,14 @@ void main() {
   DECKGL_FILTER_COLOR(gl_FragColor, geometry);
 }
 `;
-function padWithDefault(arr, defaultValue2, padWidth) {
+function padWithDefault$1(arr, defaultValue2, padWidth) {
   const newArr = [...arr];
   for (let i2 = 0; i2 < padWidth; i2 += 1) {
     newArr.push(defaultValue2);
   }
   return newArr;
 }
-const defaultProps = {
+const defaultProps$1 = {
   hoveredCell: { type: "number", value: null, compare: true },
   // We do not want to deep-compare cellColorData,
   // as it is potentially a TypedArray with millions of elements.
@@ -144027,13 +144187,13 @@ const defaultProps = {
   // Same as with cellColorData, we do not want to deep-compare expressionData.
   expressionData: { type: "object", value: null, compare: 0 }
 };
-class BitmaskLayer extends XRLayer {
+let BitmaskLayer$1 = class BitmaskLayer extends XRLayer {
   // eslint-disable-next-line class-methods-use-this
   getShaders() {
     const { colormap } = this.props;
     return {
-      fs,
-      vs,
+      fs: fs$1,
+      vs: vs$1,
       modules: [project32, picking],
       defines: {
         [COLORMAP_SHADER_PLACEHOLDER]: GLSL_COLORMAPS.includes(colormap) ? colormap : GLSL_COLORMAP_DEFAULT
@@ -144093,7 +144253,7 @@ class BitmaskLayer extends XRLayer {
         expressionTex,
         colorTexHeight: colorTex.height,
         colorTexWidth: colorTex.width,
-        channelsVisible: padWithDefault(
+        channelsVisible: padWithDefault$1(
           channelsVisible,
           false,
           // There are six texture entries on the shaders
@@ -144130,28 +144290,632 @@ class BitmaskLayer extends XRLayer {
       type: GL$1.FLOAT
     });
   }
+};
+BitmaskLayer$1.layerName = "BitmaskLayer";
+BitmaskLayer$1.defaultProps = defaultProps$1;
+const vs = `
+#define SHADER_NAME bitmask-layer-vertex-shader
+
+attribute vec2 texCoords;
+attribute vec3 positions;
+attribute vec3 positions64Low;
+attribute vec3 instancePickingColors;
+
+varying vec2 vTexCoord;
+
+void main(void) {
+  geometry.worldPosition = positions;
+  geometry.uv = texCoords;
+  geometry.pickingColor = instancePickingColors;
+  gl_Position = project_position_to_clipspace(positions, positions64Low, vec3(0.0), geometry.position);
+  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+  vTexCoord = texCoords;
+  vec4 color = vec4(0.0);
+  DECKGL_FILTER_COLOR(color, geometry);
+}
+`;
+const fs = `
+#define SHADER_NAME bitmask-layer-fragment-shader
+precision highp float;
+
+${colormaps}
+
+// Note: can have a maximum of 16 textures in most browsers
+// Reference: https://webglreport.com/
+
+// Data (mask) texture
+uniform sampler2D channel0;
+uniform sampler2D channel1;
+uniform sampler2D channel2;
+uniform sampler2D channel3;
+uniform sampler2D channel4;
+uniform sampler2D channel5;
+uniform sampler2D channel6;
+
+// Color texture
+uniform float hovered;
+
+// Channel-specific properties
+uniform bool channelsVisible[7];
+uniform float channelOpacities[7];
+uniform bool channelIsStaticColorMode[7]; // TODO: should this be a single float?
+uniform bool channelIsSetColorMode[7]; // TODO: should this be a single float?
+
+// TODO: can array of tuples/vec2 be used?
+uniform float channelColormapRangeStarts[7];
+uniform float channelColormapRangeEnds[7];
+
+uniform float multiFeatureTexSize;
+
+// Use one expressionTex for all channels, using an offset mechanism.
+uniform sampler2D valueTex;
+uniform float valueTexOffsets[7];
+uniform float valueTexHeight;
+
+// Textures for set colors, using the same offset mechanism.
+uniform sampler2D colorTex;
+uniform float colorTexOffsets[7];
+uniform float colorTexHeight;
+
+
+// Static colors
+// TODO: For some reason I cannot use uniform vec3 colors[7]; and i cannot figure out why.
+uniform vec3 color0;
+uniform vec3 color1;
+uniform vec3 color2;
+uniform vec3 color3;
+uniform vec3 color4;
+uniform vec3 color5;
+uniform vec3 color6;
+
+// Info for edge-only mode
+uniform float scaleFactor;
+uniform bool channelsFilled[7];
+uniform float channelStrokeWidths[7];
+
+// opacity
+uniform float opacity;
+
+varying vec2 vTexCoord;
+
+vec3 sampleAndGetData(sampler2D dataTex, vec2 coord, bool isFilled, float strokeWidth, bool isOn) {
+  float sampledData = texture(dataTex, coord).r;
+  float clampedSampledData = max(0., min(sampledData, 1.));
+
+  bool isEdge = true;
+
+  if(!isFilled) {
+    vec2 uTextureSize = vec2(2048.0, 2048.0);
+    vec2 onePixel = vec2(1.0, 1.0) / uTextureSize;
+
+    // Vary the edgeSize based on user-defined stroke width.
+    float edgeSize = 150.0 * strokeWidth * scaleFactor;
+
+    float pixN = texture(dataTex, coord + vec2(0.0, onePixel.y * edgeSize)).r;
+    float pixS = texture(dataTex, coord - vec2(0.0, onePixel.y * edgeSize)).r;
+    float pixW = texture(dataTex, coord + vec2(onePixel.x * edgeSize, 0.0)).r;
+    float pixE = texture(dataTex, coord - vec2(onePixel.x * edgeSize, 0.0)).r;
+
+    float pixNW = texture(dataTex, coord + vec2(onePixel.y * edgeSize, onePixel.y * edgeSize)).r;
+    float pixNE = texture(dataTex, coord + vec2(-1.0 * onePixel.x * edgeSize, onePixel.y * edgeSize)).r;
+    float pixSW = texture(dataTex, coord - vec2(onePixel.x * edgeSize, onePixel.y * edgeSize)).r;
+    float pixSE = texture(dataTex, coord - vec2(-1.0 * onePixel.x * edgeSize, onePixel.y * edgeSize)).r;
+
+    isEdge = (pixN != sampledData || pixS != sampledData || pixW != sampledData || pixE != sampledData || pixNW != sampledData || pixNE != sampledData || pixSW != sampledData || pixSE != sampledData);
+  }
+  // Return a tuple of (sampledData, isEdge)
+  return vec3(clampedSampledData * float(isOn), sampledData, float(isEdge));
+}
+
+vec4 dataToColor(vec3 sampledDataAndIsEdge, bool isStaticColorMode, vec3 channelColor, float channelOpacity, float valueOffset, float rangeStart, float rangeEnd, bool isSetColorMode, float setColorOffset) {
+  float clampedSampledDataAndIsOn = sampledDataAndIsEdge.x;
+  float sampledData = sampledDataAndIsEdge.y;
+  float isEdge = sampledDataAndIsEdge.z;
+  
+
+  vec4 hoveredColor = float(sampledData == hovered && sampledData > 0. && hovered > 0.) * vec4(0., 0., 1., 1.);
+  
+  // Colors are laid out corresponding to ids in row-major order in the texture.  So if width of the texture is 10, and you want ID 25,
+  // you need coordinate (1, 4) (i.e 2 rows down, and 5 columns over indexed from 0 for a total of 25 units covered in row major order).
+  float offsetSampledData = sampledData + valueOffset - 1.0;
+  vec2 colorTexCoord = vec2(mod(offsetSampledData, multiFeatureTexSize) / multiFeatureTexSize, floor(offsetSampledData / multiFeatureTexSize) / (valueTexHeight - 1.));
+
+  // Get expression value
+  float expressionValue = texture(valueTex, colorTexCoord).r / 255.;
+  float scaledExpressionValue = (expressionValue - rangeStart) / max(0.005, (rangeEnd - rangeStart));
+
+
+  // Get set color index value
+  vec2 setIndicesTexCoord = vec2(mod(offsetSampledData, multiFeatureTexSize) / multiFeatureTexSize, floor(offsetSampledData / multiFeatureTexSize) / (valueTexHeight - 1.));
+  float setColorIndex = texture(valueTex, setIndicesTexCoord).r;
+
+  // Initialize to the default "null" color.
+  vec3 setColor = vec3(200. / 255., 200. / 255., 200. / 255.);
+  if(setColorIndex != 0.) {
+    // Subtract one from setColorIndex because we have already checked for the "null" value.
+    setColorIndex = setColorIndex - 1.;
+
+    float setColorOffsetR = (setColorIndex + setColorOffset) * 3.0 + 0.0;
+    vec2 setColorTexCoordR = vec2(mod(setColorOffsetR, multiFeatureTexSize) / multiFeatureTexSize, floor(setColorOffsetR / multiFeatureTexSize) / (colorTexHeight - 1.));
+    float setColorR = texture(colorTex, setColorTexCoordR).r / 255.;
+
+    float setColorOffsetG = (setColorIndex + setColorOffset) * 3.0 + 1.0;
+    vec2 setColorTexCoordG = vec2(mod(setColorOffsetG, multiFeatureTexSize) / multiFeatureTexSize, floor(setColorOffsetG / multiFeatureTexSize) / (colorTexHeight - 1.));
+    float setColorG = texture(colorTex, setColorTexCoordG).r / 255.;
+
+    float setColorOffsetB = (setColorIndex + setColorOffset) * 3.0 + 2.0;
+    vec2 setColorTexCoordB = vec2(mod(setColorOffsetB, multiFeatureTexSize) / multiFeatureTexSize, floor(setColorOffsetB / multiFeatureTexSize) / (colorTexHeight - 1.));
+    float setColorB = texture(colorTex, setColorTexCoordB).r / 255.;
+
+    setColor = vec3(setColorR, setColorG, setColorB);
+  }
+
+  
+  vec4 sampledColor = (1. - (float(isStaticColorMode) + float(isSetColorMode))) * vec4(COLORMAP_FUNC(clamp(scaledExpressionValue, 0.0, 1.0)).rgb, channelOpacity) + float(isStaticColorMode) * vec4(channelColor.rgb, channelOpacity) + float(isSetColorMode) * vec4(setColor, channelOpacity);
+  // Only return a color if the data is non-zero.
+  
+  return clampedSampledDataAndIsOn * isEdge * sampledColor;
+}
+
+void main() {
+
+  // Get the color and alpha value for each channel.
+  vec3 dat0 = sampleAndGetData(channel0, vTexCoord, channelsFilled[0], channelStrokeWidths[0], channelsVisible[0]);
+  vec3 dat1 = sampleAndGetData(channel1, vTexCoord, channelsFilled[1], channelStrokeWidths[1], channelsVisible[1]);
+  vec3 dat2 = sampleAndGetData(channel2, vTexCoord, channelsFilled[2], channelStrokeWidths[2], channelsVisible[2]);
+  vec3 dat3 = sampleAndGetData(channel3, vTexCoord, channelsFilled[3], channelStrokeWidths[3], channelsVisible[3]);
+  vec3 dat4 = sampleAndGetData(channel4, vTexCoord, channelsFilled[4], channelStrokeWidths[4], channelsVisible[4]);
+  vec3 dat5 = sampleAndGetData(channel5, vTexCoord, channelsFilled[5], channelStrokeWidths[5], channelsVisible[5]);
+  vec3 dat6 = sampleAndGetData(channel6, vTexCoord, channelsFilled[6], channelStrokeWidths[6], channelsVisible[6]);
+  
+  vec4 val0 = dataToColor(dat0, channelIsStaticColorMode[0], color0, channelOpacities[0], valueTexOffsets[0], channelColormapRangeStarts[0], channelColormapRangeEnds[0], channelIsSetColorMode[0], colorTexOffsets[0]);
+  vec4 val1 = dataToColor(dat1, channelIsStaticColorMode[1], color1, channelOpacities[1], valueTexOffsets[1], channelColormapRangeStarts[1], channelColormapRangeEnds[1], channelIsSetColorMode[1], colorTexOffsets[1]);
+  vec4 val2 = dataToColor(dat2, channelIsStaticColorMode[2], color2, channelOpacities[2], valueTexOffsets[2], channelColormapRangeStarts[2], channelColormapRangeEnds[2], channelIsSetColorMode[2], colorTexOffsets[2]);
+  vec4 val3 = dataToColor(dat3, channelIsStaticColorMode[3], color3, channelOpacities[3], valueTexOffsets[3], channelColormapRangeStarts[3], channelColormapRangeEnds[3], channelIsSetColorMode[3], colorTexOffsets[3]);
+  vec4 val4 = dataToColor(dat4, channelIsStaticColorMode[4], color4, channelOpacities[4], valueTexOffsets[4], channelColormapRangeStarts[4], channelColormapRangeEnds[4], channelIsSetColorMode[4], colorTexOffsets[4]);
+  vec4 val5 = dataToColor(dat5, channelIsStaticColorMode[5], color5, channelOpacities[5], valueTexOffsets[5], channelColormapRangeStarts[5], channelColormapRangeEnds[5], channelIsSetColorMode[5], colorTexOffsets[5]);
+  vec4 val6 = dataToColor(dat6, channelIsStaticColorMode[6], color6, channelOpacities[6], valueTexOffsets[6], channelColormapRangeStarts[6], channelColormapRangeEnds[6], channelIsSetColorMode[6], colorTexOffsets[6]);
+  
+  // If all of the channels are "empty", then discard this pixel so that it is not considered during picking.
+  float emptyDat = 0.;
+  if(dat0.x == emptyDat && dat1.x == emptyDat && dat2.x == emptyDat && dat3.x == emptyDat && dat4.x == emptyDat && dat5.x == emptyDat && dat6.x == emptyDat) {
+    discard;
+  }
+  
+  // If the next channel color and the currently stored color (gl_FragColor) are identical,
+  // or the next channel color is transparent black,
+  // just use the currently stored color. Repeat this for all channels.
+
+  // Mix colors where necessary, using the alpha value of the next channel as the weight.
+  // Use the maximum alpha value as the resulting alpha value.
+  gl_FragColor = val0;
+  gl_FragColor = (val1 == gl_FragColor || val1 == vec4(0.)) ? gl_FragColor : vec4(mix(gl_FragColor, val1, val1.a).rgb, max(gl_FragColor.a, val1.a));
+  gl_FragColor = (val2 == gl_FragColor || val2 == vec4(0.)) ? gl_FragColor : vec4(mix(gl_FragColor, val2, val2.a).rgb, max(gl_FragColor.a, val2.a));
+  gl_FragColor = (val3 == gl_FragColor || val3 == vec4(0.)) ? gl_FragColor : vec4(mix(gl_FragColor, val3, val3.a).rgb, max(gl_FragColor.a, val3.a));
+  gl_FragColor = (val4 == gl_FragColor || val4 == vec4(0.)) ? gl_FragColor : vec4(mix(gl_FragColor, val4, val4.a).rgb, max(gl_FragColor.a, val4.a));
+  gl_FragColor = (val5 == gl_FragColor || val5 == vec4(0.)) ? gl_FragColor : vec4(mix(gl_FragColor, val5, val5.a).rgb, max(gl_FragColor.a, val5.a));
+  gl_FragColor = (val6 == gl_FragColor || val6 == vec4(0.)) ? gl_FragColor : vec4(mix(gl_FragColor, val6, val6.a).rgb, max(gl_FragColor.a, val6.a));
+
+  
+
+  // TODO: multiply the resulting channel-level opacity value by the layer-level opacity value.
+
+  geometry.uv = vTexCoord;
+  DECKGL_FILTER_COLOR(gl_FragColor, geometry);
+}
+`;
+function extent(values, valueof) {
+  let min2;
+  let max2;
+  if (valueof === void 0) {
+    for (const value of values) {
+      if (value != null) {
+        if (min2 === void 0) {
+          if (value >= value)
+            min2 = max2 = value;
+        } else {
+          if (min2 > value)
+            min2 = value;
+          if (max2 < value)
+            max2 = value;
+        }
+      }
+    }
+  } else {
+    let index2 = -1;
+    for (let value of values) {
+      if ((value = valueof(value, ++index2, values)) != null) {
+        if (min2 === void 0) {
+          if (value >= value)
+            min2 = max2 = value;
+        } else {
+          if (min2 > value)
+            min2 = value;
+          if (max2 < value)
+            max2 = value;
+        }
+      }
+    }
+  }
+  return [min2, max2];
+}
+function normalize(arr) {
+  const [min2, max2] = extent(arr);
+  const ratio = 255 / (max2 - min2);
+  const data = new Uint8Array(arr.map((i2) => Math.floor((i2 - min2) * ratio)));
+  return data;
+}
+function multiSetsToTextureData(multiFeatureValues, setColorValues, channelIsSetColorMode, texSize) {
+  let totalValuesLength = 0;
+  let totalColorsLength = 0;
+  channelIsSetColorMode.forEach((isSetColorMode, channelIndex) => {
+    var _a2, _b, _c, _d, _e;
+    if (isSetColorMode) {
+      totalValuesLength += ((_b = (_a2 = setColorValues[channelIndex]) == null ? void 0 : _a2.obsIndex) == null ? void 0 : _b.length) || 0;
+      totalColorsLength += (((_d = (_c = setColorValues[channelIndex]) == null ? void 0 : _c.setColors) == null ? void 0 : _d.length) || 0) * 3;
+    } else {
+      totalValuesLength += ((_e = multiFeatureValues[channelIndex]) == null ? void 0 : _e.length) || 0;
+    }
+  });
+  const valueTexHeight = Math.max(2, Math.ceil(totalValuesLength / texSize));
+  const colorTexHeight = Math.max(2, Math.ceil(totalColorsLength / texSize));
+  if (valueTexHeight > texSize) {
+    console.error("Error: length of concatenated quantitative feature values larger than maximum texture size");
+  }
+  if (colorTexHeight > texSize) {
+    console.error("Error: length of concatenated quantitative feature values larger than maximum texture size");
+  }
+  const totalData = new Uint8Array(texSize * valueTexHeight);
+  const totalColors = new Uint8Array(texSize * colorTexHeight);
+  const indicesOffsets = [];
+  const colorsOffsets = [];
+  let indexOffset = 0;
+  let colorOffset = 0;
+  channelIsSetColorMode.forEach((isSetColorMode, channelIndex) => {
+    if (isSetColorMode) {
+      const { setColorIndices, setColors, obsIndex } = setColorValues[channelIndex] || {};
+      if (setColorIndices && setColors && obsIndex) {
+        for (let i2 = 0; i2 < obsIndex.length; i2++) {
+          const colorIndex = setColorIndices.get(String(i2 + 1));
+          totalData[indexOffset + i2] = colorIndex === void 0 ? 0 : colorIndex + 1;
+        }
+        for (let i2 = 0; i2 < setColors.length; i2++) {
+          const { color: [r2, g2, b] } = setColors[i2];
+          totalColors[(colorOffset + i2) * 3 + 0] = r2;
+          totalColors[(colorOffset + i2) * 3 + 1] = g2;
+          totalColors[(colorOffset + i2) * 3 + 2] = b;
+        }
+      }
+      indicesOffsets.push(indexOffset);
+      colorsOffsets.push(colorOffset);
+      indexOffset += (obsIndex == null ? void 0 : obsIndex.length) || 0;
+      colorOffset += (setColors == null ? void 0 : setColors.length) || 0;
+    } else {
+      const featureArr = multiFeatureValues[channelIndex];
+      totalData.set(normalize(featureArr), indexOffset);
+      indicesOffsets.push(indexOffset);
+      indexOffset += featureArr.length;
+      colorsOffsets.push(colorOffset);
+    }
+  });
+  return [
+    totalData,
+    valueTexHeight,
+    indicesOffsets,
+    totalColors,
+    colorTexHeight,
+    colorsOffsets
+  ];
+}
+const MAX_CHANNELS = 7;
+const MULTI_FEATURE_TEX_SIZE = 2048;
+function padWithDefault(arr, defaultValue2, padWidth) {
+  const newArr = [...arr];
+  for (let i2 = 0; i2 < padWidth; i2 += 1) {
+    newArr.push(defaultValue2);
+  }
+  return newArr;
+}
+function getColor(arr) {
+  return arr ? arr.map((v) => v / 255) : [0, 0, 0];
+}
+const defaultProps = {
+  channelStrokeWidths: { type: "array", value: null, compare: true },
+  channelsFilled: { type: "array", value: null, compare: true },
+  channelOpacities: { type: "array", value: null, compare: true },
+  channelColors: { type: "array", value: null, compare: true },
+  hoveredCell: { type: "number", value: null, compare: true },
+  colormap: { type: "string", value: GLSL_COLORMAP_DEFAULT, compare: true },
+  expressionData: { type: "object", value: null, compare: true },
+  multiFeatureValues: { type: "array", value: null, compare: true },
+  setColorValues: { type: "array", value: null, compare: true },
+  channelFeatureValueColormaps: { type: "array", value: null, compare: true },
+  channelFeatureValueColormapRanges: { type: "array", value: null, compare: true },
+  channelIsStaticColorMode: { type: "array", value: null, compare: true },
+  channelIsSetColorMode: { type: "array", value: null, compare: true }
+};
+class BitmaskLayer2 extends XRLayer {
+  // eslint-disable-next-line class-methods-use-this
+  getShaders() {
+    const { colormap } = this.props;
+    return {
+      fs,
+      vs,
+      modules: [project32, picking],
+      defines: {
+        [COLORMAP_SHADER_PLACEHOLDER]: GLSL_COLORMAPS.includes(colormap) ? colormap : GLSL_COLORMAP_DEFAULT
+      }
+    };
+  }
+  /**
+   * Override the parent loadChannelTextures to enable
+   * up to eight channels (rather than six).
+   * Reference: https://github.com/hms-dbmi/viv/blob/v0.13.3/packages/layers/src/xr-layer/xr-layer.js#L316
+  */
+  loadChannelTextures(channelData) {
+    const textures = {
+      channel0: null,
+      channel1: null,
+      channel2: null,
+      channel3: null,
+      channel4: null,
+      channel5: null,
+      channel6: null
+    };
+    if (this.state.textures) {
+      Object.values(this.state.textures).forEach((tex) => tex && tex.delete());
+    }
+    if (channelData && Object.keys(channelData).length > 0 && channelData.data) {
+      channelData.data.forEach((d, i2) => {
+        textures[`channel${i2}`] = this.dataToTexture(d, channelData.width, channelData.height);
+      }, this);
+      this.setState({ textures });
+    }
+  }
+  updateState({ props: props2, oldProps, changeFlags }) {
+    super.updateState({ props: props2, oldProps, changeFlags });
+    if (props2.multiFeatureValues !== oldProps.multiFeatureValues || props2.setColorValues !== oldProps.setColorValues || props2.channelIsSetColorMode !== oldProps.channelIsSetColorMode) {
+      const { multiFeatureValues, setColorValues, channelIsSetColorMode } = this.props;
+      const [valueTex, colorTex, valueTexOffsets, colorTexOffsets, valueTexHeight, colorTexHeight] = this.multiSetsToTexture(multiFeatureValues, setColorValues, channelIsSetColorMode);
+      this.setState({
+        valueTex,
+        colorTex,
+        valueTexOffsets,
+        colorTexOffsets,
+        valueTexHeight,
+        colorTexHeight
+      });
+    }
+    if (props2.colormap !== oldProps.colormap) {
+      const { gl } = this.context;
+      if (this.state.model) {
+        this.state.model.delete();
+      }
+      this.setState({ model: this._getModel(gl) });
+      this.getAttributeManager().invalidateAll();
+    }
+  }
+  draw(opts2) {
+    const { uniforms } = opts2;
+    const {
+      channelStrokeWidths,
+      channelsFilled,
+      channelOpacities,
+      channelColors,
+      channelsVisible,
+      // TODO: use `channelFeatureValueColormaps` in shader,
+      // figure out how to call multiple GLSL colormap functions
+      channelFeatureValueColormaps,
+      channelFeatureValueColormapRanges,
+      channelIsStaticColorMode,
+      channelIsSetColorMode,
+      hoveredCell,
+      colorScaleLo,
+      colorScaleHi,
+      isExpressionMode,
+      zoom,
+      minZoom,
+      maxZoom,
+      zoomOffset
+      // TODO: figure out if this needs to be used or not
+    } = this.props;
+    const {
+      textures,
+      model,
+      // Expression and set index (and colors) textures with offsets
+      valueTex,
+      colorTex,
+      valueTexOffsets,
+      colorTexOffsets,
+      valueTexHeight,
+      colorTexHeight
+    } = this.state;
+    if (textures && model) {
+      const scaleFactor = 1 / 2 ** (maxZoom - zoom);
+      const colors = fromEntries(range$5(MAX_CHANNELS).map((i2) => [`color${i2}`, getColor(channelColors[i2])]));
+      model.setUniforms(Object.assign({}, uniforms, {
+        ...colors,
+        // Bitmask image channel data textures
+        ...textures,
+        multiFeatureTexSize: MULTI_FEATURE_TEX_SIZE,
+        // Expression textures with offsets
+        valueTex,
+        valueTexOffsets: padWithDefault(valueTexOffsets, 0, MAX_CHANNELS - valueTexOffsets.length),
+        valueTexHeight,
+        // Set indices and colors textures with offsets
+        colorTex,
+        colorTexOffsets: padWithDefault(colorTexOffsets, 0, MAX_CHANNELS - colorTexOffsets.length),
+        colorTexHeight,
+        // Visualization properties
+        channelsFilled: padWithDefault(
+          channelsFilled,
+          true,
+          // There are six texture entries on the shaders
+          MAX_CHANNELS - channelsFilled.length
+        ),
+        channelOpacities: padWithDefault(
+          channelOpacities,
+          0,
+          // There are six texture entries on the shaders
+          MAX_CHANNELS - channelOpacities.length
+        ),
+        channelStrokeWidths: padWithDefault(
+          channelStrokeWidths,
+          1,
+          // There are six texture entries on the shaders
+          MAX_CHANNELS - channelStrokeWidths.length
+        ),
+        channelColormapRangeStarts: padWithDefault(
+          channelFeatureValueColormapRanges.map((r2) => (r2 == null ? void 0 : r2[0]) || 0),
+          0,
+          // There are six texture entries on the shaders
+          MAX_CHANNELS - channelFeatureValueColormapRanges.length
+        ),
+        channelColormapRangeEnds: padWithDefault(
+          channelFeatureValueColormapRanges.map((r2) => (r2 == null ? void 0 : r2[1]) || 1),
+          1,
+          // There are six texture entries on the shaders
+          MAX_CHANNELS - channelFeatureValueColormapRanges.length
+        ),
+        channelIsStaticColorMode: padWithDefault(
+          channelIsStaticColorMode,
+          true,
+          // There are six texture entries on the shaders
+          MAX_CHANNELS - channelIsStaticColorMode.length
+        ),
+        channelIsSetColorMode: padWithDefault(
+          channelIsSetColorMode,
+          false,
+          // There are six texture entries on the shaders
+          MAX_CHANNELS - channelIsSetColorMode.length
+        ),
+        hovered: hoveredCell || 0,
+        channelsVisible: padWithDefault(
+          channelsVisible,
+          false,
+          // There are six texture entries on the shaders
+          MAX_CHANNELS - channelsVisible.length
+        ),
+        // uColorScaleRange: [colorScaleLo, colorScaleHi],
+        // uIsExpressionMode: isExpressionMode,
+        // uIsOutlined: false,
+        scaleFactor
+      })).draw();
+    }
+  }
+  /**
+   * This function creates textures from the data
+   */
+  dataToTexture(data, width, height) {
+    const isWebGL2On = isWebGL2$1(this.context.gl);
+    return new Texture2D(this.context.gl, {
+      width,
+      height,
+      // Only use Float32 so we don't have to write two shaders
+      data: new Float32Array(data),
+      // we don't want or need mimaps
+      mipmaps: false,
+      parameters: {
+        // NEAREST for integer data
+        [GL$1.TEXTURE_MIN_FILTER]: GL$1.NEAREST,
+        [GL$1.TEXTURE_MAG_FILTER]: GL$1.NEAREST,
+        // CLAMP_TO_EDGE to remove tile artifacts
+        [GL$1.TEXTURE_WRAP_S]: GL$1.CLAMP_TO_EDGE,
+        [GL$1.TEXTURE_WRAP_T]: GL$1.CLAMP_TO_EDGE
+      },
+      format: isWebGL2On ? GL$1.R32F : GL$1.LUMINANCE,
+      dataFormat: isWebGL2On ? GL$1.RED : GL$1.LUMINANCE,
+      type: GL$1.FLOAT
+    });
+  }
+  multiSetsToTexture(multiFeatureValues, setColorValues, channelIsSetColorMode) {
+    const isWebGL2On = isWebGL2$1(this.context.gl);
+    const [totalData, valueTexHeight, indicesOffsets, totalColors, colorTexHeight, colorsOffsets] = multiSetsToTextureData(multiFeatureValues, setColorValues, channelIsSetColorMode, MULTI_FEATURE_TEX_SIZE);
+    return [
+      // Color indices texture
+      new Texture2D(this.context.gl, {
+        width: MULTI_FEATURE_TEX_SIZE,
+        height: valueTexHeight,
+        // Only use Float32 so we don't have to write two shaders
+        data: new Float32Array(totalData),
+        // we don't want or need mimaps
+        mipmaps: false,
+        parameters: {
+          // NEAREST for integer data
+          [GL$1.TEXTURE_MIN_FILTER]: GL$1.NEAREST,
+          [GL$1.TEXTURE_MAG_FILTER]: GL$1.NEAREST,
+          // CLAMP_TO_EDGE to remove tile artifacts
+          [GL$1.TEXTURE_WRAP_S]: GL$1.CLAMP_TO_EDGE,
+          [GL$1.TEXTURE_WRAP_T]: GL$1.CLAMP_TO_EDGE
+        },
+        format: isWebGL2On ? GL$1.R32F : GL$1.LUMINANCE,
+        dataFormat: isWebGL2On ? GL$1.RED : GL$1.LUMINANCE,
+        type: GL$1.FLOAT
+      }),
+      // Colors texture
+      new Texture2D(this.context.gl, {
+        width: MULTI_FEATURE_TEX_SIZE,
+        height: colorTexHeight,
+        // Only use Float32 so we don't have to write two shaders
+        data: new Float32Array(totalColors),
+        // we don't want or need mimaps
+        mipmaps: false,
+        parameters: {
+          // NEAREST for integer data
+          [GL$1.TEXTURE_MIN_FILTER]: GL$1.NEAREST,
+          [GL$1.TEXTURE_MAG_FILTER]: GL$1.NEAREST,
+          // CLAMP_TO_EDGE to remove tile artifacts
+          [GL$1.TEXTURE_WRAP_S]: GL$1.CLAMP_TO_EDGE,
+          [GL$1.TEXTURE_WRAP_T]: GL$1.CLAMP_TO_EDGE
+        },
+        format: isWebGL2On ? GL$1.R32F : GL$1.LUMINANCE,
+        dataFormat: isWebGL2On ? GL$1.RED : GL$1.LUMINANCE,
+        type: GL$1.FLOAT
+      }),
+      // Offsets
+      indicesOffsets,
+      colorsOffsets,
+      // Texture heights
+      valueTexHeight,
+      colorTexHeight
+    ];
+  }
+}
+BitmaskLayer2.layerName = "BitmaskLayer";
+BitmaskLayer2.defaultProps = defaultProps;
+const toRgbUIString = (on, arr, theme) => {
+  const color = on || theme === "light" && (arr == null ? void 0 : arr.every((i2) => i2 === 255)) ? [220, 220, 220] : arr;
+  return `rgb(${color})`;
+};
+function filterSelection(loader, selection) {
+  if (!selection) {
+    return selection;
+  }
+  const data = Array.isArray(loader) ? loader[loader.length - 1] : loader;
+  const { labels } = data;
+  return fromEntries(Object.entries(selection).filter(([key]) => labels.includes(key)));
 }
-BitmaskLayer.layerName = "BitmaskLayer";
-BitmaskLayer.defaultProps = defaultProps;
 async function getSingleSelectionStats2D({ loader, selection }) {
   const data = Array.isArray(loader) ? loader[loader.length - 1] : loader;
-  const raster = await data.getRaster({ selection });
+  const filteredSelection = filterSelection(loader, selection);
+  const raster = await data.getRaster({ selection: filteredSelection });
   const selectionStats = getChannelStats(raster.data);
   const { domain, contrastLimits: slider } = selectionStats;
   return { domain, slider };
 }
 async function getSingleSelectionStats3D({ loader, selection }) {
   const lowResSource = loader[loader.length - 1];
+  const filteredSelection = filterSelection(lowResSource, selection);
   const { shape, labels } = lowResSource;
   const sizeZ = shape[labels.indexOf("z")] >> loader.length - 1;
   const raster0 = await lowResSource.getRaster({
-    selection: { ...selection, z: 0 }
+    selection: { ...filteredSelection, z: 0 }
   });
   const rasterMid = await lowResSource.getRaster({
-    selection: { ...selection, z: Math.floor(sizeZ / 2) }
+    selection: { ...filteredSelection, z: Math.floor(sizeZ / 2) }
   });
   const rasterTop = await lowResSource.getRaster({
-    selection: { ...selection, z: Math.max(0, sizeZ - 1) }
+    selection: { ...filteredSelection, z: Math.max(0, sizeZ - 1) }
   });
   const stats0 = getChannelStats(raster0.data);
   const statsMid = getChannelStats(rasterMid.data);
@@ -144187,6 +144951,45 @@ const getMultiSelectionStats = async ({ loader, selections, use3d }) => {
   const sliders = stats.map((stat) => stat.slider);
   return { domains, sliders };
 };
+function getPhysicalSizeScalingMatrix(loader) {
+  var _a2;
+  const { x: x2, y: y2, z: z2 } = ((_a2 = loader == null ? void 0 : loader.meta) == null ? void 0 : _a2.physicalSizes) ?? {};
+  if ((x2 == null ? void 0 : x2.size) && (y2 == null ? void 0 : y2.size) && (z2 == null ? void 0 : z2.size)) {
+    const min2 = Math.min(z2.size, x2.size, y2.size);
+    const ratio = [x2.size / min2, y2.size / min2, z2.size / min2];
+    return new Matrix4().scale(ratio);
+  }
+  return new Matrix4().identity();
+}
+function getBoundingCube(loader) {
+  const source = Array.isArray(loader) ? loader[0] : loader;
+  const { shape, labels } = source;
+  const physicalSizeScalingMatrix = getPhysicalSizeScalingMatrix(source);
+  const xSlice = [0, physicalSizeScalingMatrix[0] * shape[labels.indexOf("x")]];
+  const ySlice = [0, physicalSizeScalingMatrix[5] * shape[labels.indexOf("y")]];
+  const zSlice = [
+    0,
+    physicalSizeScalingMatrix[10] * shape[labels.indexOf("z")]
+  ];
+  return [xSlice, ySlice, zSlice];
+}
+function abbreviateNumber(value) {
+  const maxLength = 5;
+  let maxNaiveDigits = maxLength;
+  if (!Number.isInteger(value)) {
+    --maxNaiveDigits;
+  }
+  if (value < 1) {
+    --maxNaiveDigits;
+  }
+  const naive = Intl.NumberFormat("en-US", {
+    maximumSignificantDigits: maxNaiveDigits,
+    useGrouping: false
+  }).format(value);
+  if (naive.length <= maxLength)
+    return naive;
+  return value.toExponential(0);
+}
 function square(x2, y2, r2) {
   return [[x2, y2 + r2], [x2 + r2, y2], [x2, y2 - r2], [x2 - r2, y2]];
 }
@@ -144226,6 +145029,35 @@ function getSourceFromLoader(loader, level) {
   const source = Array.isArray(data) ? data[level || data.length - 1] : data;
   return source;
 }
+const getStatsForResolution = (loader, resolution) => {
+  const { shape, labels } = loader[resolution];
+  const height = shape[labels.indexOf("y")];
+  const width = shape[labels.indexOf("x")];
+  const depth = shape[labels.indexOf("z")];
+  const depthDownsampled = Math.max(1, depth >> resolution);
+  const totalBytes = 4 * height * width * depthDownsampled;
+  return {
+    height,
+    width,
+    depthDownsampled,
+    totalBytes
+  };
+};
+const canLoadResolution = (loader, resolution) => {
+  var _a2, _b, _c;
+  const {
+    totalBytes,
+    height,
+    width,
+    depthDownsampled
+  } = getStatsForResolution(
+    loader,
+    resolution
+  );
+  const maxHeapSize = ((_a2 = window.performance) == null ? void 0 : _a2.memory) && ((_c = (_b = window.performance) == null ? void 0 : _b.memory) == null ? void 0 : _c.jsHeapSizeLimit) / 2;
+  const maxSize = maxHeapSize || 2 ** 31 - 1;
+  return totalBytes < maxSize && height <= 2048 && depthDownsampled <= 2048 && width <= 2048 && depthDownsampled > 1;
+};
 function isRgb(loader, channels2) {
   const source = getSourceFromLoader(loader);
   const { shape, dtype, labels } = source;
@@ -144238,6 +145070,32 @@ function isRgb(loader, channels2) {
   }
   return false;
 }
+function physicalSizeToMatrix(xSize, ySize, zSize, xUnit, yUnit, zUnit) {
+  const hasZPhyscialSize = Boolean(zSize) && Boolean(zUnit);
+  const hasYPhyscialSize = Boolean(ySize) && Boolean(yUnit);
+  const hasXPhyscialSize = Boolean(xSize) && Boolean(xUnit);
+  if (!hasXPhyscialSize || !hasYPhyscialSize) {
+    return new Matrix4().identity();
+  }
+  const sizes = [
+    unit(`${xSize} ${xUnit}`.replace("µ", "u")),
+    unit(`${ySize} ${yUnit}`.replace("µ", "u"))
+  ];
+  if (hasZPhyscialSize) {
+    sizes.push(unit(`${zSize} ${zUnit}`.replace("µ", "u")));
+  }
+  const scale2 = sizes.map((i2) => divide(i2, unit("1 um")));
+  if (!sizes[0].equals(sizes[1])) {
+    scale2[1] = divide(sizes[1], sizes[0]);
+  }
+  if (!scale2[2]) {
+    scale2[2] = 1;
+  }
+  if (isEqual$1(scale2, [1, 1, 1])) {
+    return new Matrix4().identity();
+  }
+  return new Matrix4().scale([...scale2]);
+}
 function getMetaWithTransformMatrices(imageMeta, imageLoaders) {
   const sources = imageLoaders.map((loader) => getSourceFromLoader(loader));
   if (imageMeta.map((meta2) => {
@@ -144475,8 +145333,64 @@ function coordinateTransformationsToMatrix(coordinateTransformations, axes) {
   }
   return mat;
 }
+function hexToRgb(hex) {
+  const result = /^#?([A-F\d]{2})([A-F\d]{2})([A-F\d]{2})$/i.exec(hex);
+  return [
+    parseInt(result[1].toLowerCase(), 16),
+    parseInt(result[2].toLowerCase(), 16),
+    parseInt(result[3].toLowerCase(), 16)
+  ];
+}
+function normalizeCoordinateTransformations(coordinateTransformations, datasets) {
+  var _a2;
+  let result = [];
+  if (Array.isArray(coordinateTransformations)) {
+    result = coordinateTransformations.map((transform2) => {
+      if (transform2.input && transform2.output) {
+        const { type } = transform2;
+        if (type === "translation") {
+          return {
+            type,
+            translation: transform2.translation
+          };
+        }
+        if (type === "scale") {
+          return {
+            type,
+            scale: transform2.scale
+          };
+        }
+        if (type === "identity") {
+          return { type };
+        }
+        console.warn(`Coordinate transformation type "${type}" is not supported.`);
+      }
+      return transform2;
+    });
+  }
+  if (Array.isArray((_a2 = datasets == null ? void 0 : datasets[0]) == null ? void 0 : _a2.coordinateTransformations)) {
+    result = [
+      ...datasets[0].coordinateTransformations,
+      ...result
+    ];
+  }
+  return result;
+}
+function getDomains() {
+  const domains = {};
+  const needMin = ["Int8", "Int16", "Int32"];
+  Object.keys(DTYPE_VALUES).forEach((dtype) => {
+    const { max: max2 } = DTYPE_VALUES[dtype];
+    const min2 = needMin.includes(dtype) ? -(max2 + 1) : 0;
+    domains[dtype] = [min2, max2];
+  });
+  return domains;
+}
+const DOMAINS = getDomains();
 export {
+  filterSelection as A,
   BaseDecoder as B,
+  DOMAINS as C,
   DEFAULT_CELLS_LAYER as D,
   GLOBAL_LABELS as G,
   DEFAULT_MOLECULES_LAYER as a,
@@ -144493,5 +145407,16 @@ export {
   getNgffAxes as l,
   getNgffAxesForTiff as m,
   coordinateTransformationsToMatrix as n,
-  square as s
+  hexToRgb as o,
+  physicalSizeToMatrix as p,
+  getStatsForResolution as q,
+  canLoadResolution as r,
+  square as s,
+  normalizeCoordinateTransformations as t,
+  toRgbUIString as u,
+  getSingleSelectionStats as v,
+  getMultiSelectionStats as w,
+  getPhysicalSizeScalingMatrix as x,
+  getBoundingCube as y,
+  abbreviateNumber as z
 };