@vitessce/config 3.5.12 → 3.6.0

package/dist/index.js

@@ -1,643 +1,379 @@
 const FileType = {
   // Joint file types
   ANNDATA_ZARR: "anndata.zarr",
-  ANNDATA_ZARR_ZIP: "anndata.zarr.zip",
-  ANNDATA_H5AD: "anndata.h5ad",
-  SPATIALDATA_ZARR: "spatialdata.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",
-  OBS_FEATURE_MATRIX_CSV: "obsFeatureMatrix.csv",
-  OBS_SEGMENTATIONS_JSON: "obsSegmentations.json",
-  OBS_SETS_CSV: "obsSets.csv",
-  OBS_SETS_JSON: "obsSets.json",
-  SAMPLE_SETS_CSV: "sampleSets.csv",
-  // OME-Zarr
-  IMAGE_OME_ZARR: "image.ome-zarr",
-  OBS_SEGMENTATIONS_OME_ZARR: "obsSegmentations.ome-zarr",
-  // OME-Zarr - Zipped
-  IMAGE_OME_ZARR_ZIP: "image.ome-zarr.zip",
-  OBS_SEGMENTATIONS_OME_ZARR_ZIP: "obsSegmentations.ome-zarr.zip",
-  // AnnData
-  OBS_FEATURE_MATRIX_ANNDATA_ZARR: "obsFeatureMatrix.anndata.zarr",
-  OBS_FEATURE_COLUMNS_ANNDATA_ZARR: "obsFeatureColumns.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",
-  FEATURE_LABELS_ANNDATA_ZARR: "featureLabels.anndata.zarr",
-  SAMPLE_EDGES_ANNDATA_ZARR: "sampleEdges.anndata.zarr",
-  SAMPLE_SETS_ANNDATA_ZARR: "sampleSets.anndata.zarr",
-  COMPARISON_METADATA_ANNDATA_ZARR: "comparisonMetadata.anndata.zarr",
-  COMPARATIVE_FEATURE_STATS_ANNDATA_ZARR: "comparativeFeatureStats.anndata.zarr",
-  COMPARATIVE_FEATURE_SET_STATS_ANNDATA_ZARR: "comparativeFeatureSetStats.anndata.zarr",
-  COMPARATIVE_OBS_SET_STATS_ANNDATA_ZARR: "comparativeObsSetStats.anndata.zarr",
-  // AnnData - zipped
-  OBS_FEATURE_MATRIX_ANNDATA_ZARR_ZIP: "obsFeatureMatrix.anndata.zarr.zip",
-  OBS_FEATURE_COLUMNS_ANNDATA_ZARR_ZIP: "obsFeatureColumns.anndata.zarr.zip",
-  OBS_SETS_ANNDATA_ZARR_ZIP: "obsSets.anndata.zarr.zip",
-  OBS_EMBEDDING_ANNDATA_ZARR_ZIP: "obsEmbedding.anndata.zarr.zip",
-  OBS_SPOTS_ANNDATA_ZARR_ZIP: "obsSpots.anndata.zarr.zip",
-  OBS_POINTS_ANNDATA_ZARR_ZIP: "obsPoints.anndata.zarr.zip",
-  OBS_LOCATIONS_ANNDATA_ZARR_ZIP: "obsLocations.anndata.zarr.zip",
-  OBS_SEGMENTATIONS_ANNDATA_ZARR_ZIP: "obsSegmentations.anndata.zarr.zip",
-  OBS_LABELS_ANNDATA_ZARR_ZIP: "obsLabels.anndata.zarr.zip",
-  FEATURE_LABELS_ANNDATA_ZARR_ZIP: "featureLabels.anndata.zarr.zip",
-  SAMPLE_EDGES_ANNDATA_ZARR_ZIP: "sampleEdges.anndata.zarr.zip",
-  SAMPLE_SETS_ANNDATA_ZARR_ZIP: "sampleSets.anndata.zarr.zip",
-  COMPARISON_METADATA_ANNDATA_ZARR_ZIP: "comparisonMetadata.anndata.zarr.zip",
-  COMPARATIVE_FEATURE_STATS_ANNDATA_ZARR_ZIP: "comparativeFeatureStats.anndata.zarr.zip",
-  COMPARATIVE_FEATURE_SET_STATS_ANNDATA_ZARR_ZIP: "comparativeFeatureSetStats.anndata.zarr.zip",
-  COMPARATIVE_OBS_SET_STATS_ANNDATA_ZARR_ZIP: "comparativeObsSetStats.anndata.zarr.zip",
-  // AnnData - h5ad via reference spec
-  OBS_FEATURE_MATRIX_ANNDATA_H5AD: "obsFeatureMatrix.anndata.h5ad",
-  OBS_FEATURE_COLUMNS_ANNDATA_H5AD: "obsFeatureColumns.anndata.h5ad",
-  OBS_SETS_ANNDATA_H5AD: "obsSets.anndata.h5ad",
-  OBS_EMBEDDING_ANNDATA_H5AD: "obsEmbedding.anndata.h5ad",
-  OBS_SPOTS_ANNDATA_H5AD: "obsSpots.anndata.h5ad",
-  OBS_POINTS_ANNDATA_H5AD: "obsPoints.anndata.h5ad",
-  OBS_LOCATIONS_ANNDATA_H5AD: "obsLocations.anndata.h5ad",
-  OBS_SEGMENTATIONS_ANNDATA_H5AD: "obsSegmentations.anndata.h5ad",
-  OBS_LABELS_ANNDATA_H5AD: "obsLabels.anndata.h5ad",
-  FEATURE_LABELS_ANNDATA_H5AD: "featureLabels.anndata.h5ad",
-  SAMPLE_EDGES_ANNDATA_H5AD: "sampleEdges.anndata.h5ad",
-  SAMPLE_SETS_ANNDATA_H5AD: "sampleSets.anndata.h5ad",
-  COMPARISON_METADATA_ANNDATA_H5AD: "comparisonMetadata.anndata.h5ad",
-  COMPARATIVE_FEATURE_STATS_ANNDATA_H5AD: "comparativeFeatureStats.anndata.h5ad",
-  COMPARATIVE_FEATURE_SET_STATS_ANNDATA_H5AD: "comparativeFeatureSetStats.anndata.h5ad",
-  COMPARATIVE_OBS_SET_STATS_ANNDATA_H5AD: "comparativeObsSetStats.anndata.h5ad",
-  // SpatialData
-  IMAGE_SPATIALDATA_ZARR: "image.spatialdata.zarr",
-  LABELS_SPATIALDATA_ZARR: "labels.spatialdata.zarr",
-  SHAPES_SPATIALDATA_ZARR: "shapes.spatialdata.zarr",
-  OBS_FEATURE_MATRIX_SPATIALDATA_ZARR: "obsFeatureMatrix.spatialdata.zarr",
-  OBS_SETS_SPATIALDATA_ZARR: "obsSets.spatialdata.zarr",
-  OBS_SPOTS_SPATIALDATA_ZARR: "obsSpots.spatialdata.zarr",
-  FEATURE_LABELS_SPATIALDATA_ZARR: "featureLabels.spatialdata.zarr",
-  // TODO:
-  // OBS_POINTS_SPATIALDATA_ZARR: 'obsPoints.spatialdata.zarr',
-  // OBS_LOCATIONS_SPATIALDATA_ZARR: 'obsLocations.spatialdata.zarr',
-  // MuData
-  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",
-  FEATURE_LABELS_MUDATA_ZARR: "featureLabels.mudata.zarr",
-  GENOMIC_PROFILES_ZARR: "genomic-profiles.zarr",
-  NEIGHBORHOODS_JSON: "neighborhoods.json",
-  // OME-TIFF
-  IMAGE_OME_TIFF: "image.ome-tiff",
-  OBS_SEGMENTATIONS_OME_TIFF: "obsSegmentations.ome-tiff",
-  // GLB
-  OBS_SEGMENTATIONS_GLB: "obsSegmentations.glb",
-  // New file types to support old file types:
-  // - cells.json
-  OBS_EMBEDDING_CELLS_JSON: "obsEmbedding.cells.json",
-  OBS_SEGMENTATIONS_CELLS_JSON: "obsSegmentations.cells.json",
-  OBS_LOCATIONS_CELLS_JSON: "obsLocations.cells.json",
-  OBS_LABELS_CELLS_JSON: "obsLabels.cells.json",
-  // - cell-sets.json
-  OBS_SETS_CELL_SETS_JSON: "obsSets.cell-sets.json",
-  // - genes.json
-  OBS_FEATURE_MATRIX_GENES_JSON: "obsFeatureMatrix.genes.json",
-  // - clusters.json
-  OBS_FEATURE_MATRIX_CLUSTERS_JSON: "obsFeatureMatrix.clusters.json",
-  // - expression-matrix.zarr
-  OBS_FEATURE_MATRIX_EXPRESSION_MATRIX_ZARR: "obsFeatureMatrix.expression-matrix.zarr",
-  // - raster.json
-  IMAGE_RASTER_JSON: "image.raster.json",
-  OBS_SEGMENTATIONS_RASTER_JSON: "obsSegmentations.raster.json",
-  // - molecules.json
-  OBS_LOCATIONS_MOLECULES_JSON: "obsLocations.molecules.json",
-  OBS_LABELS_MOLECULES_JSON: "obsLabels.molecules.json",
-  // Legacy joint file types
-  CELLS_JSON: "cells.json",
-  CELL_SETS_JSON: "cell-sets.json",
-  ANNDATA_CELL_SETS_ZARR: "anndata-cell-sets.zarr",
-  ANNDATA_CELLS_ZARR: "anndata-cells.zarr",
-  EXPRESSION_MATRIX_ZARR: "expression-matrix.zarr",
-  MOLECULES_JSON: "molecules.json",
   RASTER_JSON: "raster.json",
-  RASTER_OME_ZARR: "raster.ome-zarr",
-  CLUSTERS_JSON: "clusters.json",
-  GENES_JSON: "genes.json",
-  ANNDATA_EXPRESSION_MATRIX_ZARR: "anndata-expression-matrix.zarr"
+  RASTER_OME_ZARR: "raster.ome-zarr"
 };
 const CoordinationType = {
   META_COORDINATION_SCOPES: "metaCoordinationScopes",
   META_COORDINATION_SCOPES_BY: "metaCoordinationScopesBy",
   DATASET: "dataset",
-  // Entity types
-  OBS_TYPE: "obsType",
-  FEATURE_TYPE: "featureType",
-  FEATURE_VALUE_TYPE: "featureValueType",
-  OBS_LABELS_TYPE: "obsLabelsType",
-  FEATURE_LABELS_TYPE: "featureLabelsType",
   // Other types
   EMBEDDING_TYPE: "embeddingType",
-  EMBEDDING_ZOOM: "embeddingZoom",
-  EMBEDDING_ROTATION: "embeddingRotation",
-  EMBEDDING_TARGET_X: "embeddingTargetX",
-  EMBEDDING_TARGET_Y: "embeddingTargetY",
-  EMBEDDING_TARGET_Z: "embeddingTargetZ",
-  EMBEDDING_OBS_SET_POLYGONS_VISIBLE: "embeddingObsSetPolygonsVisible",
-  EMBEDDING_OBS_SET_LABELS_VISIBLE: "embeddingObsSetLabelsVisible",
-  EMBEDDING_OBS_SET_LABEL_SIZE: "embeddingObsSetLabelSize",
-  EMBEDDING_OBS_RADIUS: "embeddingObsRadius",
-  EMBEDDING_OBS_RADIUS_MODE: "embeddingObsRadiusMode",
-  EMBEDDING_OBS_OPACITY: "embeddingObsOpacity",
-  EMBEDDING_OBS_OPACITY_MODE: "embeddingObsOpacityMode",
   SPATIAL_ZOOM: "spatialZoom",
-  SPATIAL_ROTATION: "spatialRotation",
   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",
-  SPATIAL_ROTATION_ORBIT: "spatialRotationOrbit",
-  SPATIAL_ORBIT_AXIS: "spatialOrbitAxis",
-  SPATIAL_AXIS_FIXED: "spatialAxisFixed",
-  HEATMAP_ZOOM_X: "heatmapZoomX",
-  HEATMAP_ZOOM_Y: "heatmapZoomY",
-  HEATMAP_TARGET_X: "heatmapTargetX",
-  HEATMAP_TARGET_Y: "heatmapTargetY",
-  OBS_HIGHLIGHT: "obsHighlight",
-  OBS_SELECTION: "obsSelection",
-  OBS_SET_SELECTION: "obsSetSelection",
-  OBS_SELECTION_MODE: "obsSelectionMode",
-  OBS_FILTER: "obsFilter",
-  OBS_SET_FILTER: "obsSetFilter",
-  OBS_FILTER_MODE: "obsFilterMode",
-  OBS_SET_HIGHLIGHT: "obsSetHighlight",
-  OBS_SET_EXPANSION: "obsSetExpansion",
-  OBS_SET_COLOR: "obsSetColor",
-  FEATURE_HIGHLIGHT: "featureHighlight",
-  FEATURE_SELECTION: "featureSelection",
-  FEATURE_SET_SELECTION: "featureSetSelection",
-  FEATURE_SELECTION_MODE: "featureSelectionMode",
-  FEATURE_FILTER: "featureFilter",
-  FEATURE_SET_FILTER: "featureSetFilter",
-  FEATURE_FILTER_MODE: "featureFilterMode",
-  FEATURE_VALUE_COLORMAP: "featureValueColormap",
-  FEATURE_VALUE_TRANSFORM: "featureValueTransform",
-  FEATURE_VALUE_COLORMAP_RANGE: "featureValueColormapRange",
-  FEATURE_AGGREGATION_STRATEGY: "featureAggregationStrategy",
-  OBS_COLOR_ENCODING: "obsColorEncoding",
   SPATIAL_IMAGE_LAYER: "spatialImageLayer",
-  SPATIAL_SEGMENTATION_LAYER: "spatialSegmentationLayer",
-  SPATIAL_POINT_LAYER: "spatialPointLayer",
-  SPATIAL_NEIGHBORHOOD_LAYER: "spatialNeighborhoodLayer",
-  GENOMIC_ZOOM_X: "genomicZoomX",
-  GENOMIC_ZOOM_Y: "genomicZoomY",
-  GENOMIC_TARGET_X: "genomicTargetX",
-  GENOMIC_TARGET_Y: "genomicTargetY",
-  ADDITIONAL_OBS_SETS: "additionalObsSets",
-  // TODO: use obsHighlight rather than moleculeHighlight.
-  MOLECULE_HIGHLIGHT: "moleculeHighlight",
-  GATING_FEATURE_SELECTION_X: "gatingFeatureSelectionX",
-  GATING_FEATURE_SELECTION_Y: "gatingFeatureSelectionY",
-  FEATURE_VALUE_TRANSFORM_COEFFICIENT: "featureValueTransformCoefficient",
-  FEATURE_VALUE_POSITIVITY_THRESHOLD: "featureValuePositivityThreshold",
-  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",
-  // For whole spatial view
-  VOLUMETRIC_RENDERING_ALGORITHM: "volumetricRenderingAlgorithm",
-  // Could be per-image-layer
-  SPATIAL_TARGET_RESOLUTION: "spatialTargetResolution",
-  // Per-spatial-layer
-  // 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",
-  // In micrometers?
-  SPATIAL_SPOT_FILLED: "spatialSpotFilled",
-  SPATIAL_SPOT_STROKE_WIDTH: "spatialSpotStrokeWidth",
-  SPATIAL_LAYER_COLOR: "spatialLayerColor",
-  PIXEL_HIGHLIGHT: "pixelHighlight",
-  // Per-image-layer
-  TOOLTIP_CROSSHAIRS_VISIBLE: "tooltipCrosshairsVisible",
-  LEGEND_VISIBLE: "legendVisible",
-  SPATIAL_CHANNEL_LABELS_VISIBLE: "spatialChannelLabelsVisible",
-  SPATIAL_CHANNEL_LABELS_ORIENTATION: "spatialChannelLabelsOrientation",
-  SPATIAL_CHANNEL_LABEL_SIZE: "spatialChannelLabelSize",
-  // Multi-sample / comparative
-  SAMPLE_TYPE: "sampleType",
-  SAMPLE_SELECTION: "sampleSelection",
-  SAMPLE_SET_SELECTION: "sampleSetSelection",
-  SAMPLE_SELECTION_MODE: "sampleSelectionMode",
-  SAMPLE_FILTER: "sampleFilter",
-  SAMPLE_SET_FILTER: "sampleSetFilter",
-  SAMPLE_FILTER_MODE: "sampleFilterMode",
-  SAMPLE_SET_COLOR: "sampleSetColor",
-  SAMPLE_HIGHLIGHT: "sampleHighlight",
-  EMBEDDING_POINTS_VISIBLE: "embeddingPointsVisible",
-  EMBEDDING_CONTOURS_VISIBLE: "embeddingContoursVisible",
-  EMBEDDING_CONTOURS_FILLED: "embeddingContoursFilled",
-  EMBEDDING_CONTOUR_PERCENTILES: "embeddingContourPercentiles",
-  CONTOUR_COLOR_ENCODING: "contourColorEncoding",
-  CONTOUR_COLOR: "contourColor",
-  // For volcano plot:
-  FEATURE_POINT_SIGNIFICANCE_THRESHOLD: "featurePointSignificanceThreshold",
-  FEATURE_LABEL_SIGNIFICANCE_THRESHOLD: "featureLabelSignificanceThreshold",
-  FEATURE_POINT_FOLD_CHANGE_THRESHOLD: "featurePointFoldChangeThreshold",
-  FEATURE_LABEL_FOLD_CHANGE_THRESHOLD: "featureLabelFoldChangeThreshold",
-  // Treemap
-  HIERARCHY_LEVELS: "hierarchyLevels"
+  SPATIAL_SEGMENTATION_LAYER: "spatialSegmentationLayer"
 };
-var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 function commonjsRequire(path) {
   throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
 }
-var pluralize = { exports: {} };
-(function(module, exports) {
-  (function(root, pluralize2) {
-    if (typeof commonjsRequire === "function" && true && true) {
-      module.exports = pluralize2();
-    } else {
-      root.pluralize = pluralize2();
-    }
-  })(commonjsGlobal, function() {
-    var pluralRules = [];
-    var singularRules = [];
-    var uncountables = {};
-    var irregularPlurals = {};
-    var irregularSingles = {};
-    function sanitizeRule(rule) {
-      if (typeof rule === "string") {
-        return new RegExp("^" + rule + "$", "i");
+var pluralize$1 = { exports: {} };
+var pluralize = pluralize$1.exports;
+var hasRequiredPluralize;
+function requirePluralize() {
+  if (hasRequiredPluralize) return pluralize$1.exports;
+  hasRequiredPluralize = 1;
+  (function(module, exports) {
+    (function(root, pluralize2) {
+      if (typeof commonjsRequire === "function" && true && true) {
+        module.exports = pluralize2();
+      } else {
+        root.pluralize = pluralize2();
       }
-      return rule;
-    }
-    function restoreCase(word, token) {
-      if (word === token)
-        return token;
-      if (word === word.toLowerCase())
+    })(pluralize, function() {
+      var pluralRules = [];
+      var singularRules = [];
+      var uncountables = {};
+      var irregularPlurals = {};
+      var irregularSingles = {};
+      function sanitizeRule(rule) {
+        if (typeof rule === "string") {
+          return new RegExp("^" + rule + "$", "i");
+        }
+        return rule;
+      }
+      function restoreCase(word, token) {
+        if (word === token) return token;
+        if (word === word.toLowerCase()) return token.toLowerCase();
+        if (word === word.toUpperCase()) return token.toUpperCase();
+        if (word[0] === word[0].toUpperCase()) {
+          return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+        }
         return token.toLowerCase();
-      if (word === word.toUpperCase())
-        return token.toUpperCase();
-      if (word[0] === word[0].toUpperCase()) {
-        return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
       }
-      return token.toLowerCase();
-    }
-    function interpolate(str, args) {
-      return str.replace(/\$(\d{1,2})/g, function(match, index) {
-        return args[index] || "";
-      });
-    }
-    function replace(word, rule) {
-      return word.replace(rule[0], function(match, index) {
-        var result = interpolate(rule[1], arguments);
-        if (match === "") {
-          return restoreCase(word[index - 1], result);
+      function interpolate(str, args) {
+        return str.replace(/\$(\d{1,2})/g, function(match, index) {
+          return args[index] || "";
+        });
+      }
+      function replace(word, rule) {
+        return word.replace(rule[0], function(match, index) {
+          var result = interpolate(rule[1], arguments);
+          if (match === "") {
+            return restoreCase(word[index - 1], result);
+          }
+          return restoreCase(match, result);
+        });
+      }
+      function sanitizeWord(token, word, rules) {
+        if (!token.length || uncountables.hasOwnProperty(token)) {
+          return word;
+        }
+        var len = rules.length;
+        while (len--) {
+          var rule = rules[len];
+          if (rule[0].test(word)) return replace(word, rule);
         }
-        return restoreCase(match, result);
-      });
-    }
-    function sanitizeWord(token, word, rules) {
-      if (!token.length || uncountables.hasOwnProperty(token)) {
         return word;
       }
-      var len = rules.length;
-      while (len--) {
-        var rule = rules[len];
-        if (rule[0].test(word))
-          return replace(word, rule);
+      function replaceWord(replaceMap, keepMap, rules) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token)) {
+            return restoreCase(word, token);
+          }
+          if (replaceMap.hasOwnProperty(token)) {
+            return restoreCase(word, replaceMap[token]);
+          }
+          return sanitizeWord(token, word, rules);
+        };
       }
-      return word;
-    }
-    function replaceWord(replaceMap, keepMap, rules) {
-      return function(word) {
-        var token = word.toLowerCase();
-        if (keepMap.hasOwnProperty(token)) {
-          return restoreCase(word, token);
-        }
-        if (replaceMap.hasOwnProperty(token)) {
-          return restoreCase(word, replaceMap[token]);
+      function checkWord(replaceMap, keepMap, rules, bool) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token)) return true;
+          if (replaceMap.hasOwnProperty(token)) return false;
+          return sanitizeWord(token, token, rules) === token;
+        };
+      }
+      function pluralize2(word, count, inclusive) {
+        var pluralized = count === 1 ? pluralize2.singular(word) : pluralize2.plural(word);
+        return (inclusive ? count + " " : "") + pluralized;
+      }
+      pluralize2.plural = replaceWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize2.isPlural = checkWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize2.singular = replaceWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize2.isSingular = checkWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize2.addPluralRule = function(rule, replacement) {
+        pluralRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize2.addSingularRule = function(rule, replacement) {
+        singularRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize2.addUncountableRule = function(word) {
+        if (typeof word === "string") {
+          uncountables[word.toLowerCase()] = true;
+          return;
         }
-        return sanitizeWord(token, word, rules);
+        pluralize2.addPluralRule(word, "$0");
+        pluralize2.addSingularRule(word, "$0");
       };
-    }
-    function checkWord(replaceMap, keepMap, rules, bool) {
-      return function(word) {
-        var token = word.toLowerCase();
-        if (keepMap.hasOwnProperty(token))
-          return true;
-        if (replaceMap.hasOwnProperty(token))
-          return false;
-        return sanitizeWord(token, token, rules) === token;
+      pluralize2.addIrregularRule = function(single, plural) {
+        plural = plural.toLowerCase();
+        single = single.toLowerCase();
+        irregularSingles[single] = plural;
+        irregularPlurals[plural] = single;
       };
-    }
-    function pluralize2(word, count, inclusive) {
-      var pluralized = count === 1 ? pluralize2.singular(word) : pluralize2.plural(word);
-      return (inclusive ? count + " " : "") + pluralized;
-    }
-    pluralize2.plural = replaceWord(
-      irregularSingles,
-      irregularPlurals,
-      pluralRules
-    );
-    pluralize2.isPlural = checkWord(
-      irregularSingles,
-      irregularPlurals,
-      pluralRules
-    );
-    pluralize2.singular = replaceWord(
-      irregularPlurals,
-      irregularSingles,
-      singularRules
-    );
-    pluralize2.isSingular = checkWord(
-      irregularPlurals,
-      irregularSingles,
-      singularRules
-    );
-    pluralize2.addPluralRule = function(rule, replacement) {
-      pluralRules.push([sanitizeRule(rule), replacement]);
-    };
-    pluralize2.addSingularRule = function(rule, replacement) {
-      singularRules.push([sanitizeRule(rule), replacement]);
-    };
-    pluralize2.addUncountableRule = function(word) {
-      if (typeof word === "string") {
-        uncountables[word.toLowerCase()] = true;
-        return;
-      }
-      pluralize2.addPluralRule(word, "$0");
-      pluralize2.addSingularRule(word, "$0");
-    };
-    pluralize2.addIrregularRule = function(single, plural) {
-      plural = plural.toLowerCase();
-      single = single.toLowerCase();
-      irregularSingles[single] = plural;
-      irregularPlurals[plural] = single;
-    };
-    [
-      // Pronouns.
-      ["I", "we"],
-      ["me", "us"],
-      ["he", "they"],
-      ["she", "they"],
-      ["them", "them"],
-      ["myself", "ourselves"],
-      ["yourself", "yourselves"],
-      ["itself", "themselves"],
-      ["herself", "themselves"],
-      ["himself", "themselves"],
-      ["themself", "themselves"],
-      ["is", "are"],
-      ["was", "were"],
-      ["has", "have"],
-      ["this", "these"],
-      ["that", "those"],
-      // Words ending in with a consonant and `o`.
-      ["echo", "echoes"],
-      ["dingo", "dingoes"],
-      ["volcano", "volcanoes"],
-      ["tornado", "tornadoes"],
-      ["torpedo", "torpedoes"],
-      // Ends with `us`.
-      ["genus", "genera"],
-      ["viscus", "viscera"],
-      // Ends with `ma`.
-      ["stigma", "stigmata"],
-      ["stoma", "stomata"],
-      ["dogma", "dogmata"],
-      ["lemma", "lemmata"],
-      ["schema", "schemata"],
-      ["anathema", "anathemata"],
-      // Other irregular rules.
-      ["ox", "oxen"],
-      ["axe", "axes"],
-      ["die", "dice"],
-      ["yes", "yeses"],
-      ["foot", "feet"],
-      ["eave", "eaves"],
-      ["goose", "geese"],
-      ["tooth", "teeth"],
-      ["quiz", "quizzes"],
-      ["human", "humans"],
-      ["proof", "proofs"],
-      ["carve", "carves"],
-      ["valve", "valves"],
-      ["looey", "looies"],
-      ["thief", "thieves"],
-      ["groove", "grooves"],
-      ["pickaxe", "pickaxes"],
-      ["passerby", "passersby"]
-    ].forEach(function(rule) {
-      return pluralize2.addIrregularRule(rule[0], rule[1]);
-    });
-    [
-      [/s?$/i, "s"],
-      [/[^\u0000-\u007F]$/i, "$0"],
-      [/([^aeiou]ese)$/i, "$1"],
-      [/(ax|test)is$/i, "$1es"],
-      [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
-      [/(e[mn]u)s?$/i, "$1s"],
-      [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
-      [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
-      [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
-      [/(seraph|cherub)(?:im)?$/i, "$1im"],
-      [/(her|at|gr)o$/i, "$1oes"],
-      [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
-      [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
-      [/sis$/i, "ses"],
-      [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
-      [/([^aeiouy]|qu)y$/i, "$1ies"],
-      [/([^ch][ieo][ln])ey$/i, "$1ies"],
-      [/(x|ch|ss|sh|zz)$/i, "$1es"],
-      [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
-      [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
-      [/(pe)(?:rson|ople)$/i, "$1ople"],
-      [/(child)(?:ren)?$/i, "$1ren"],
-      [/eaux$/i, "$0"],
-      [/m[ae]n$/i, "men"],
-      ["thou", "you"]
-    ].forEach(function(rule) {
-      return pluralize2.addPluralRule(rule[0], rule[1]);
-    });
-    [
-      [/s$/i, ""],
-      [/(ss)$/i, "$1"],
-      [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
-      [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
-      [/ies$/i, "y"],
-      [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
-      [/\b(mon|smil)ies$/i, "$1ey"],
-      [/\b((?:tit)?m|l)ice$/i, "$1ouse"],
-      [/(seraph|cherub)im$/i, "$1"],
-      [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"],
-      [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"],
-      [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
-      [/(test)(?:is|es)$/i, "$1is"],
-      [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
-      [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
-      [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
-      [/(alumn|alg|vertebr)ae$/i, "$1a"],
-      [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
-      [/(matr|append)ices$/i, "$1ix"],
-      [/(pe)(rson|ople)$/i, "$1rson"],
-      [/(child)ren$/i, "$1"],
-      [/(eau)x?$/i, "$1"],
-      [/men$/i, "man"]
-    ].forEach(function(rule) {
-      return pluralize2.addSingularRule(rule[0], rule[1]);
+      [
+        // Pronouns.
+        ["I", "we"],
+        ["me", "us"],
+        ["he", "they"],
+        ["she", "they"],
+        ["them", "them"],
+        ["myself", "ourselves"],
+        ["yourself", "yourselves"],
+        ["itself", "themselves"],
+        ["herself", "themselves"],
+        ["himself", "themselves"],
+        ["themself", "themselves"],
+        ["is", "are"],
+        ["was", "were"],
+        ["has", "have"],
+        ["this", "these"],
+        ["that", "those"],
+        // Words ending in with a consonant and `o`.
+        ["echo", "echoes"],
+        ["dingo", "dingoes"],
+        ["volcano", "volcanoes"],
+        ["tornado", "tornadoes"],
+        ["torpedo", "torpedoes"],
+        // Ends with `us`.
+        ["genus", "genera"],
+        ["viscus", "viscera"],
+        // Ends with `ma`.
+        ["stigma", "stigmata"],
+        ["stoma", "stomata"],
+        ["dogma", "dogmata"],
+        ["lemma", "lemmata"],
+        ["schema", "schemata"],
+        ["anathema", "anathemata"],
+        // Other irregular rules.
+        ["ox", "oxen"],
+        ["axe", "axes"],
+        ["die", "dice"],
+        ["yes", "yeses"],
+        ["foot", "feet"],
+        ["eave", "eaves"],
+        ["goose", "geese"],
+        ["tooth", "teeth"],
+        ["quiz", "quizzes"],
+        ["human", "humans"],
+        ["proof", "proofs"],
+        ["carve", "carves"],
+        ["valve", "valves"],
+        ["looey", "looies"],
+        ["thief", "thieves"],
+        ["groove", "grooves"],
+        ["pickaxe", "pickaxes"],
+        ["passerby", "passersby"]
+      ].forEach(function(rule) {
+        return pluralize2.addIrregularRule(rule[0], rule[1]);
+      });
+      [
+        [/s?$/i, "s"],
+        [/[^\u0000-\u007F]$/i, "$0"],
+        [/([^aeiou]ese)$/i, "$1"],
+        [/(ax|test)is$/i, "$1es"],
+        [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
+        [/(e[mn]u)s?$/i, "$1s"],
+        [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
+        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
+        [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
+        [/(seraph|cherub)(?:im)?$/i, "$1im"],
+        [/(her|at|gr)o$/i, "$1oes"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
+        [/sis$/i, "ses"],
+        [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
+        [/([^aeiouy]|qu)y$/i, "$1ies"],
+        [/([^ch][ieo][ln])ey$/i, "$1ies"],
+        [/(x|ch|ss|sh|zz)$/i, "$1es"],
+        [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
+        [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
+        [/(pe)(?:rson|ople)$/i, "$1ople"],
+        [/(child)(?:ren)?$/i, "$1ren"],
+        [/eaux$/i, "$0"],
+        [/m[ae]n$/i, "men"],
+        ["thou", "you"]
+      ].forEach(function(rule) {
+        return pluralize2.addPluralRule(rule[0], rule[1]);
+      });
+      [
+        [/s$/i, ""],
+        [/(ss)$/i, "$1"],
+        [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
+        [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
+        [/ies$/i, "y"],
+        [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
+        [/\b(mon|smil)ies$/i, "$1ey"],
+        [/\b((?:tit)?m|l)ice$/i, "$1ouse"],
+        [/(seraph|cherub)im$/i, "$1"],
+        [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"],
+        [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"],
+        [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
+        [/(test)(?:is|es)$/i, "$1is"],
+        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
+        [/(alumn|alg|vertebr)ae$/i, "$1a"],
+        [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
+        [/(matr|append)ices$/i, "$1ix"],
+        [/(pe)(rson|ople)$/i, "$1rson"],
+        [/(child)ren$/i, "$1"],
+        [/(eau)x?$/i, "$1"],
+        [/men$/i, "man"]
+      ].forEach(function(rule) {
+        return pluralize2.addSingularRule(rule[0], rule[1]);
+      });
+      [
+        // Singular words with no plurals.
+        "adulthood",
+        "advice",
+        "agenda",
+        "aid",
+        "aircraft",
+        "alcohol",
+        "ammo",
+        "analytics",
+        "anime",
+        "athletics",
+        "audio",
+        "bison",
+        "blood",
+        "bream",
+        "buffalo",
+        "butter",
+        "carp",
+        "cash",
+        "chassis",
+        "chess",
+        "clothing",
+        "cod",
+        "commerce",
+        "cooperation",
+        "corps",
+        "debris",
+        "diabetes",
+        "digestion",
+        "elk",
+        "energy",
+        "equipment",
+        "excretion",
+        "expertise",
+        "firmware",
+        "flounder",
+        "fun",
+        "gallows",
+        "garbage",
+        "graffiti",
+        "hardware",
+        "headquarters",
+        "health",
+        "herpes",
+        "highjinks",
+        "homework",
+        "housework",
+        "information",
+        "jeans",
+        "justice",
+        "kudos",
+        "labour",
+        "literature",
+        "machinery",
+        "mackerel",
+        "mail",
+        "media",
+        "mews",
+        "moose",
+        "music",
+        "mud",
+        "manga",
+        "news",
+        "only",
+        "personnel",
+        "pike",
+        "plankton",
+        "pliers",
+        "police",
+        "pollution",
+        "premises",
+        "rain",
+        "research",
+        "rice",
+        "salmon",
+        "scissors",
+        "series",
+        "sewage",
+        "shambles",
+        "shrimp",
+        "software",
+        "species",
+        "staff",
+        "swine",
+        "tennis",
+        "traffic",
+        "transportation",
+        "trout",
+        "tuna",
+        "wealth",
+        "welfare",
+        "whiting",
+        "wildebeest",
+        "wildlife",
+        "you",
+        /pok[eé]mon$/i,
+        // Regexes.
+        /[^aeiou]ese$/i,
+        // "chinese", "japanese"
+        /deer$/i,
+        // "deer", "reindeer"
+        /fish$/i,
+        // "fish", "blowfish", "angelfish"
+        /measles$/i,
+        /o[iu]s$/i,
+        // "carnivorous"
+        /pox$/i,
+        // "chickpox", "smallpox"
+        /sheep$/i
+      ].forEach(pluralize2.addUncountableRule);
+      return pluralize2;
     });
-    [
-      // Singular words with no plurals.
-      "adulthood",
-      "advice",
-      "agenda",
-      "aid",
-      "aircraft",
-      "alcohol",
-      "ammo",
-      "analytics",
-      "anime",
-      "athletics",
-      "audio",
-      "bison",
-      "blood",
-      "bream",
-      "buffalo",
-      "butter",
-      "carp",
-      "cash",
-      "chassis",
-      "chess",
-      "clothing",
-      "cod",
-      "commerce",
-      "cooperation",
-      "corps",
-      "debris",
-      "diabetes",
-      "digestion",
-      "elk",
-      "energy",
-      "equipment",
-      "excretion",
-      "expertise",
-      "firmware",
-      "flounder",
-      "fun",
-      "gallows",
-      "garbage",
-      "graffiti",
-      "hardware",
-      "headquarters",
-      "health",
-      "herpes",
-      "highjinks",
-      "homework",
-      "housework",
-      "information",
-      "jeans",
-      "justice",
-      "kudos",
-      "labour",
-      "literature",
-      "machinery",
-      "mackerel",
-      "mail",
-      "media",
-      "mews",
-      "moose",
-      "music",
-      "mud",
-      "manga",
-      "news",
-      "only",
-      "personnel",
-      "pike",
-      "plankton",
-      "pliers",
-      "police",
-      "pollution",
-      "premises",
-      "rain",
-      "research",
-      "rice",
-      "salmon",
-      "scissors",
-      "series",
-      "sewage",
-      "shambles",
-      "shrimp",
-      "software",
-      "species",
-      "staff",
-      "swine",
-      "tennis",
-      "traffic",
-      "transportation",
-      "trout",
-      "tuna",
-      "wealth",
-      "welfare",
-      "whiting",
-      "wildebeest",
-      "wildlife",
-      "you",
-      /pok[eé]mon$/i,
-      // Regexes.
-      /[^aeiou]ese$/i,
-      // "chinese", "japanese"
-      /deer$/i,
-      // "deer", "reindeer"
-      /fish$/i,
-      // "fish", "blowfish", "angelfish"
-      /measles$/i,
-      /o[iu]s$/i,
-      // "carnivorous"
-      /pox$/i,
-      // "chickpox", "smallpox"
-      /sheep$/i
-    ].forEach(pluralize2.addUncountableRule);
-    return pluralize2;
-  });
-})(pluralize);
-var pluralizeExports = pluralize.exports;
+  })(pluralize$1);
+  return pluralize$1.exports;
+}
+var pluralizeExports = requirePluralize();
 const plur = /* @__PURE__ */ getDefaultExportFromCjs(pluralizeExports);
 plur.addPluralRule("glomerulus", "glomeruli");
 plur.addPluralRule("interstitium", "interstitia");
@@ -688,257 +424,260 @@ function getInitialCoordinationScopeName(datasetUid, dataType, i = null) {
   const prefix = getInitialCoordinationScopePrefix(datasetUid, dataType);
   return `${prefix}${i === null ? 0 : i}`;
 }
-var loglevel = { exports: {} };
-(function(module) {
-  (function(root, definition) {
-    if (module.exports) {
-      module.exports = definition();
-    } else {
-      root.log = definition();
-    }
-  })(commonjsGlobal, function() {
-    var noop = function() {
-    };
-    var undefinedType = "undefined";
-    var isIE = typeof window !== undefinedType && typeof window.navigator !== undefinedType && /Trident\/|MSIE /.test(window.navigator.userAgent);
-    var logMethods = [
-      "trace",
-      "debug",
-      "info",
-      "warn",
-      "error"
-    ];
-    var _loggersByName = {};
-    var defaultLogger = null;
-    function bindMethod(obj, methodName) {
-      var method = obj[methodName];
-      if (typeof method.bind === "function") {
-        return method.bind(obj);
+var loglevel$1 = { exports: {} };
+var loglevel = loglevel$1.exports;
+var hasRequiredLoglevel;
+function requireLoglevel() {
+  if (hasRequiredLoglevel) return loglevel$1.exports;
+  hasRequiredLoglevel = 1;
+  (function(module) {
+    (function(root, definition) {
+      if (module.exports) {
+        module.exports = definition();
       } else {
-        try {
-          return Function.prototype.bind.call(method, obj);
-        } catch (e) {
-          return function() {
-            return Function.prototype.apply.apply(method, [obj, arguments]);
-          };
-        }
+        root.log = definition();
       }
-    }
-    function traceForIE() {
-      if (console.log) {
-        if (console.log.apply) {
-          console.log.apply(console, arguments);
+    })(loglevel, function() {
+      var noop = function() {
+      };
+      var undefinedType = "undefined";
+      var isIE = typeof window !== undefinedType && typeof window.navigator !== undefinedType && /Trident\/|MSIE /.test(window.navigator.userAgent);
+      var logMethods = [
+        "trace",
+        "debug",
+        "info",
+        "warn",
+        "error"
+      ];
+      var _loggersByName = {};
+      var defaultLogger = null;
+      function bindMethod(obj, methodName) {
+        var method = obj[methodName];
+        if (typeof method.bind === "function") {
+          return method.bind(obj);
         } else {
-          Function.prototype.apply.apply(console.log, [console, arguments]);
+          try {
+            return Function.prototype.bind.call(method, obj);
+          } catch (e) {
+            return function() {
+              return Function.prototype.apply.apply(method, [obj, arguments]);
+            };
+          }
         }
       }
-      if (console.trace)
-        console.trace();
-    }
-    function realMethod(methodName) {
-      if (methodName === "debug") {
-        methodName = "log";
-      }
-      if (typeof console === undefinedType) {
-        return false;
-      } else if (methodName === "trace" && isIE) {
-        return traceForIE;
-      } else if (console[methodName] !== void 0) {
-        return bindMethod(console, methodName);
-      } else if (console.log !== void 0) {
-        return bindMethod(console, "log");
-      } else {
-        return noop;
-      }
-    }
-    function replaceLoggingMethods() {
-      var level = this.getLevel();
-      for (var i = 0; i < logMethods.length; i++) {
-        var methodName = logMethods[i];
-        this[methodName] = i < level ? noop : this.methodFactory(methodName, level, this.name);
-      }
-      this.log = this.debug;
-      if (typeof console === undefinedType && level < this.levels.SILENT) {
-        return "No console available for logging";
+      function traceForIE() {
+        if (console.log) {
+          if (console.log.apply) {
+            console.log.apply(console, arguments);
+          } else {
+            Function.prototype.apply.apply(console.log, [console, arguments]);
+          }
+        }
+        if (console.trace) console.trace();
       }
-    }
-    function enableLoggingWhenConsoleArrives(methodName) {
-      return function() {
-        if (typeof console !== undefinedType) {
-          replaceLoggingMethods.call(this);
-          this[methodName].apply(this, arguments);
+      function realMethod(methodName) {
+        if (methodName === "debug") {
+          methodName = "log";
+        }
+        if (typeof console === undefinedType) {
+          return false;
+        } else if (methodName === "trace" && isIE) {
+          return traceForIE;
+        } else if (console[methodName] !== void 0) {
+          return bindMethod(console, methodName);
+        } else if (console.log !== void 0) {
+          return bindMethod(console, "log");
+        } else {
+          return noop;
         }
-      };
-    }
-    function defaultMethodFactory(methodName, _level, _loggerName) {
-      return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments);
-    }
-    function Logger(name, factory) {
-      var self2 = this;
-      var inheritedLevel;
-      var defaultLevel;
-      var userLevel;
-      var storageKey = "loglevel";
-      if (typeof name === "string") {
-        storageKey += ":" + name;
-      } else if (typeof name === "symbol") {
-        storageKey = void 0;
       }
-      function persistLevelIfPossible(levelNum) {
-        var levelName = (logMethods[levelNum] || "silent").toUpperCase();
-        if (typeof window === undefinedType || !storageKey)
-          return;
-        try {
-          window.localStorage[storageKey] = levelName;
-          return;
-        } catch (ignore) {
+      function replaceLoggingMethods() {
+        var level = this.getLevel();
+        for (var i = 0; i < logMethods.length; i++) {
+          var methodName = logMethods[i];
+          this[methodName] = i < level ? noop : this.methodFactory(methodName, level, this.name);
         }
-        try {
-          window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";";
-        } catch (ignore) {
+        this.log = this.debug;
+        if (typeof console === undefinedType && level < this.levels.SILENT) {
+          return "No console available for logging";
         }
       }
-      function getPersistedLevel() {
-        var storedLevel;
-        if (typeof window === undefinedType || !storageKey)
-          return;
-        try {
-          storedLevel = window.localStorage[storageKey];
-        } catch (ignore) {
+      function enableLoggingWhenConsoleArrives(methodName) {
+        return function() {
+          if (typeof console !== undefinedType) {
+            replaceLoggingMethods.call(this);
+            this[methodName].apply(this, arguments);
+          }
+        };
+      }
+      function defaultMethodFactory(methodName, _level, _loggerName) {
+        return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments);
+      }
+      function Logger(name, factory) {
+        var self = this;
+        var inheritedLevel;
+        var defaultLevel;
+        var userLevel;
+        var storageKey = "loglevel";
+        if (typeof name === "string") {
+          storageKey += ":" + name;
+        } else if (typeof name === "symbol") {
+          storageKey = void 0;
         }
-        if (typeof storedLevel === undefinedType) {
+        function persistLevelIfPossible(levelNum) {
+          var levelName = (logMethods[levelNum] || "silent").toUpperCase();
+          if (typeof window === undefinedType || !storageKey) return;
           try {
-            var cookie = window.document.cookie;
-            var cookieName = encodeURIComponent(storageKey);
-            var location = cookie.indexOf(cookieName + "=");
-            if (location !== -1) {
-              storedLevel = /^([^;]+)/.exec(
-                cookie.slice(location + cookieName.length + 1)
-              )[1];
-            }
+            window.localStorage[storageKey] = levelName;
+            return;
+          } catch (ignore) {
+          }
+          try {
+            window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";";
           } catch (ignore) {
           }
         }
-        if (self2.levels[storedLevel] === void 0) {
-          storedLevel = void 0;
-        }
-        return storedLevel;
-      }
-      function clearPersistedLevel() {
-        if (typeof window === undefinedType || !storageKey)
-          return;
-        try {
-          window.localStorage.removeItem(storageKey);
-        } catch (ignore) {
+        function getPersistedLevel() {
+          var storedLevel;
+          if (typeof window === undefinedType || !storageKey) return;
+          try {
+            storedLevel = window.localStorage[storageKey];
+          } catch (ignore) {
+          }
+          if (typeof storedLevel === undefinedType) {
+            try {
+              var cookie = window.document.cookie;
+              var cookieName = encodeURIComponent(storageKey);
+              var location = cookie.indexOf(cookieName + "=");
+              if (location !== -1) {
+                storedLevel = /^([^;]+)/.exec(
+                  cookie.slice(location + cookieName.length + 1)
+                )[1];
+              }
+            } catch (ignore) {
+            }
+          }
+          if (self.levels[storedLevel] === void 0) {
+            storedLevel = void 0;
+          }
+          return storedLevel;
         }
-        try {
-          window.document.cookie = encodeURIComponent(storageKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
-        } catch (ignore) {
+        function clearPersistedLevel() {
+          if (typeof window === undefinedType || !storageKey) return;
+          try {
+            window.localStorage.removeItem(storageKey);
+          } catch (ignore) {
+          }
+          try {
+            window.document.cookie = encodeURIComponent(storageKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+          } catch (ignore) {
+          }
         }
-      }
-      function normalizeLevel(input) {
-        var level = input;
-        if (typeof level === "string" && self2.levels[level.toUpperCase()] !== void 0) {
-          level = self2.levels[level.toUpperCase()];
+        function normalizeLevel(input) {
+          var level = input;
+          if (typeof level === "string" && self.levels[level.toUpperCase()] !== void 0) {
+            level = self.levels[level.toUpperCase()];
+          }
+          if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
+            return level;
+          } else {
+            throw new TypeError("log.setLevel() called with invalid level: " + input);
+          }
         }
-        if (typeof level === "number" && level >= 0 && level <= self2.levels.SILENT) {
-          return level;
-        } else {
-          throw new TypeError("log.setLevel() called with invalid level: " + input);
+        self.name = name;
+        self.levels = {
+          "TRACE": 0,
+          "DEBUG": 1,
+          "INFO": 2,
+          "WARN": 3,
+          "ERROR": 4,
+          "SILENT": 5
+        };
+        self.methodFactory = factory || defaultMethodFactory;
+        self.getLevel = function() {
+          if (userLevel != null) {
+            return userLevel;
+          } else if (defaultLevel != null) {
+            return defaultLevel;
+          } else {
+            return inheritedLevel;
+          }
+        };
+        self.setLevel = function(level, persist) {
+          userLevel = normalizeLevel(level);
+          if (persist !== false) {
+            persistLevelIfPossible(userLevel);
+          }
+          return replaceLoggingMethods.call(self);
+        };
+        self.setDefaultLevel = function(level) {
+          defaultLevel = normalizeLevel(level);
+          if (!getPersistedLevel()) {
+            self.setLevel(level, false);
+          }
+        };
+        self.resetLevel = function() {
+          userLevel = null;
+          clearPersistedLevel();
+          replaceLoggingMethods.call(self);
+        };
+        self.enableAll = function(persist) {
+          self.setLevel(self.levels.TRACE, persist);
+        };
+        self.disableAll = function(persist) {
+          self.setLevel(self.levels.SILENT, persist);
+        };
+        self.rebuild = function() {
+          if (defaultLogger !== self) {
+            inheritedLevel = normalizeLevel(defaultLogger.getLevel());
+          }
+          replaceLoggingMethods.call(self);
+          if (defaultLogger === self) {
+            for (var childName in _loggersByName) {
+              _loggersByName[childName].rebuild();
+            }
+          }
+        };
+        inheritedLevel = normalizeLevel(
+          defaultLogger ? defaultLogger.getLevel() : "WARN"
+        );
+        var initialLevel = getPersistedLevel();
+        if (initialLevel != null) {
+          userLevel = normalizeLevel(initialLevel);
         }
+        replaceLoggingMethods.call(self);
       }
-      self2.name = name;
-      self2.levels = {
-        "TRACE": 0,
-        "DEBUG": 1,
-        "INFO": 2,
-        "WARN": 3,
-        "ERROR": 4,
-        "SILENT": 5
-      };
-      self2.methodFactory = factory || defaultMethodFactory;
-      self2.getLevel = function() {
-        if (userLevel != null) {
-          return userLevel;
-        } else if (defaultLevel != null) {
-          return defaultLevel;
-        } else {
-          return inheritedLevel;
+      defaultLogger = new Logger();
+      defaultLogger.getLogger = function getLogger(name) {
+        if (typeof name !== "symbol" && typeof name !== "string" || name === "") {
+          throw new TypeError("You must supply a name when creating a logger.");
         }
-      };
-      self2.setLevel = function(level, persist) {
-        userLevel = normalizeLevel(level);
-        if (persist !== false) {
-          persistLevelIfPossible(userLevel);
+        var logger = _loggersByName[name];
+        if (!logger) {
+          logger = _loggersByName[name] = new Logger(
+            name,
+            defaultLogger.methodFactory
+          );
         }
-        return replaceLoggingMethods.call(self2);
+        return logger;
       };
-      self2.setDefaultLevel = function(level) {
-        defaultLevel = normalizeLevel(level);
-        if (!getPersistedLevel()) {
-          self2.setLevel(level, false);
+      var _log = typeof window !== undefinedType ? window.log : void 0;
+      defaultLogger.noConflict = function() {
+        if (typeof window !== undefinedType && window.log === defaultLogger) {
+          window.log = _log;
         }
+        return defaultLogger;
       };
-      self2.resetLevel = function() {
-        userLevel = null;
-        clearPersistedLevel();
-        replaceLoggingMethods.call(self2);
+      defaultLogger.getLoggers = function getLoggers() {
+        return _loggersByName;
       };
-      self2.enableAll = function(persist) {
-        self2.setLevel(self2.levels.TRACE, persist);
-      };
-      self2.disableAll = function(persist) {
-        self2.setLevel(self2.levels.SILENT, persist);
-      };
-      self2.rebuild = function() {
-        if (defaultLogger !== self2) {
-          inheritedLevel = normalizeLevel(defaultLogger.getLevel());
-        }
-        replaceLoggingMethods.call(self2);
-        if (defaultLogger === self2) {
-          for (var childName in _loggersByName) {
-            _loggersByName[childName].rebuild();
-          }
-        }
-      };
-      inheritedLevel = normalizeLevel(
-        defaultLogger ? defaultLogger.getLevel() : "WARN"
-      );
-      var initialLevel = getPersistedLevel();
-      if (initialLevel != null) {
-        userLevel = normalizeLevel(initialLevel);
-      }
-      replaceLoggingMethods.call(self2);
-    }
-    defaultLogger = new Logger();
-    defaultLogger.getLogger = function getLogger(name) {
-      if (typeof name !== "symbol" && typeof name !== "string" || name === "") {
-        throw new TypeError("You must supply a name when creating a logger.");
-      }
-      var logger = _loggersByName[name];
-      if (!logger) {
-        logger = _loggersByName[name] = new Logger(
-          name,
-          defaultLogger.methodFactory
-        );
-      }
-      return logger;
-    };
-    var _log = typeof window !== undefinedType ? window.log : void 0;
-    defaultLogger.noConflict = function() {
-      if (typeof window !== undefinedType && window.log === defaultLogger) {
-        window.log = _log;
-      }
+      defaultLogger["default"] = defaultLogger;
       return defaultLogger;
-    };
-    defaultLogger.getLoggers = function getLoggers() {
-      return _loggersByName;
-    };
-    defaultLogger["default"] = defaultLogger;
-    return defaultLogger;
-  });
-})(loglevel);
-var loglevelExports = loglevel.exports;
+    });
+  })(loglevel$1);
+  return loglevel$1.exports;
+}
+var loglevelExports = requireLoglevel();
 const log = /* @__PURE__ */ getDefaultExportFromCjs(loglevelExports);
 class VitessceConfigDatasetFile {
   /**
@@ -1823,8 +1562,7 @@ const filterViews = (hintsConfig, possibleViews) => {
   const resultViews = [];
   requiredViews.forEach((requiredView) => {
     const match = possibleViews.find((possibleView) => possibleView[0] === requiredView);
-    if (match)
-      resultViews.push(match);
+    if (match) resultViews.push(match);
   });
   if (resultViews.length === 0) {
     throw new Error("No views found that are compatible with the supplied dataset URLs and hint.");