@vitessce/biomarker-select 3.5.9 → 3.5.10

package/dist/index.js

@@ -1,6 +1,6 @@
 import * as React from "react";
 import React__default, { Children, isValidElement, cloneElement, createElement, PureComponent, useRef, useEffect, useMemo, useState, useCallback } from "react";
-import { useLoaders, useCoordination, useViewConfigStoreApi, useViewConfig, useSetViewConfig, useMatchingLoader, useColumnNameMapping, useAsyncFunction, useComparisonMetadata } from "@vitessce/vit-s";
+import { useLoaders, useCoordination, useViewConfigStoreApi, useViewConfig, useSetViewConfig, useMatchingLoader, useColumnNameMapping, useAsyncFunction, useComparisonMetadata, useReady, TitleInfo } from "@vitessce/vit-s";
 import * as ReactDOM from "react-dom";
 import ReactDOM__default from "react-dom";
 function getDefaultExportFromCjs(x) {
@@ -917,7 +917,9 @@ const ViewType = {
   LINK_CONTROLLER: "linkController",
   NEUROGLANCER: "neuroglancer",
   DUAL_SCATTERPLOT: "dualScatterplot",
-  TREEMAP: "treemap"
+  TREEMAP: "treemap",
+  SAMPLE_SET_PAIR_MANAGER: "sampleSetPairManager",
+  FEATURE_STATS_TABLE: "featureStatsTable"
 };
 const DataType = {
   OBS_LABELS: "obsLabels",
@@ -1106,6 +1108,30 @@ const CoordinationType = {
   // Treemap
   HIERARCHY_LEVELS: "hierarchyLevels"
 };
+const ViewHelpMapping = {
+  SCATTERPLOT: "The scatterplot displays two-dimensional (pre-computed) dimensionality reduction results (such as from t-SNE or UMAP). Each point on the scatterplot represents an observation (e.g., cell).",
+  HEATMAP: "The heatmap displays an observation-by-feature (e.g., cell-by-gene) matrix, typically with transformed (e.g., normalized or standardized) values.",
+  SPATIAL: "The spatial view displays (potentially layered) spatially-resolved data including RGB or multiplexed images, segmentations of observations (bitmask- or polygon-based), and/or points (e.g., representing FISH transcripts).",
+  DESCRIPTION: "The description view displays additional information about a dataset. When images are included in a dataset, the description view also includes image metadata (if contained in the image files).",
+  STATUS: "The status view displays debugging messages, including app-wide error messages when datasets fail to load or when schemas fail to validate. Details about the entity under the mouse cursor (cell, gene, and/or molecule) are displayed during hover interactions.",
+  LAYER_CONTROLLER: "The spatial layer controller provides an interface for manipulating the visualization layers displayed in the spatial view.",
+  GENOMIC_PROFILES: "The genomic profiles view displays genome browser tracks (using the genomic-profiles data type) containing bar plots, where the genome is along the x-axis and the value at each genome position is encoded with a bar along the y-axis.",
+  GATING: "The gating scatterplot displays expression data for two genes (along the X and Y axes). Users can select two genes, and the scatterplot is dynamically generated using observation-by-feature matrix data. Gating can then be performed by using the lasso or box select tools.",
+  FEATURE_LIST: "The feature list controller displays an interactive list of features (e.g., genes).",
+  OBS_SETS: "The observation sets controller displays an interactive list of (potentially hierarchical) observation sets (e.g., cell clusters or cell type annotations).",
+  OBS_SET_SIZES: "The observation set sizes view displays a bar plot with the currently-selected observation sets (e.g., cell types) on the x-axis and bars representing their size (e.g., number of cells) on the y-axis.",
+  OBS_SET_FEATURE_VALUE_DISTRIBUTION: "The observation set feature value distribution view displays a violin plot with values (e.g., expression values) per set (e.g., cell type) for the selected feature (e.g., gene).",
+  FEATURE_VALUE_HISTOGRAM: "The feature value histogram displays the distribution of values (e.g., expression) for the selected feature (e.g., gene).",
+  DOT_PLOT: "The dot plot displays summary information about expression of the selected features (e.g., genes) for each selected observation set (e.g., cell type).",
+  FEATURE_BAR_PLOT: "The feature bar plot displays one bar per observation (e.g., cell) along the x-axis, where the value of a selected feature (e.g., gene) is encoded along the y-axis.",
+  NEUROGLANCER: "The Neuroglancer view displays 3d meshes using Neuroglancer developed by Google.",
+  TREEMAP: "The treemap provides an overview of the current state of sample-level or cell-level selection and filtering.",
+  VOLCANO_PLOT: "The volcano plot displays differential expression results. Each data point represents a feature (as opposed to an observation).",
+  OBS_SET_COMPOSITION_BAR_PLOT: "The set composition bar plot displays the results of a compositional analysis conducted using the scCODA method (Büttner et al. 2021 Nature Communications).",
+  FEATURE_SET_ENRICHMENT_BAR_PLOT: "The feature set enrichment bar plot displays the results of a hypergeometric test applied to the differential expression test results to identify enriched pathway gene sets.",
+  SAMPLE_SET_PAIR_MANAGER: "Select pairs of sample groups.",
+  FEATURE_STATS_TABLE: "This table displays per-feature statistics, for example, from a differential expression test."
+};
 const COMPONENT_COORDINATION_TYPES = {
   [ViewType.NEUROGLANCER]: [
     CoordinationType.DATASET
@@ -1606,6 +1632,33 @@ const COMPONENT_COORDINATION_TYPES = {
     CoordinationType.FEATURE_POINT_FOLD_CHANGE_THRESHOLD,
     CoordinationType.FEATURE_LABEL_FOLD_CHANGE_THRESHOLD
   ],
+  [ViewType.FEATURE_STATS_TABLE]: [
+    CoordinationType.DATASET,
+    CoordinationType.OBS_TYPE,
+    CoordinationType.FEATURE_TYPE,
+    CoordinationType.SAMPLE_TYPE,
+    // For selection of case-control sets of samples:
+    CoordinationType.SAMPLE_SET_SELECTION,
+    // For selection of one-vs-others sets of observations:
+    CoordinationType.OBS_SET_SELECTION,
+    // TODO: CoordinationType.FEATURE_SET_SELECTION,
+    // TODO: CoordinationType.FEATURE_SET_HIGHLIGHT,
+    // TODO: CoordinationType.FEATURE_SET_COLOR,
+    CoordinationType.FEATURE_HIGHLIGHT,
+    CoordinationType.FEATURE_SELECTION,
+    CoordinationType.FEATURE_VALUE_COLORMAP,
+    CoordinationType.FEATURE_VALUE_COLORMAP_RANGE,
+    // TODO: CoordinationType.FEATURE_COLOR_ENCODING,
+    // TODO: CoordinationType.ADDITIONAL_FEATURE_SETS,
+    CoordinationType.TOOLTIPS_VISIBLE,
+    CoordinationType.ADDITIONAL_OBS_SETS,
+    CoordinationType.OBS_SET_COLOR,
+    CoordinationType.SAMPLE_SET_COLOR,
+    CoordinationType.FEATURE_POINT_SIGNIFICANCE_THRESHOLD,
+    CoordinationType.FEATURE_LABEL_SIGNIFICANCE_THRESHOLD,
+    CoordinationType.FEATURE_POINT_FOLD_CHANGE_THRESHOLD,
+    CoordinationType.FEATURE_LABEL_FOLD_CHANGE_THRESHOLD
+  ],
   [ViewType.OBS_SET_COMPOSITION_BAR_PLOT]: [
     CoordinationType.DATASET,
     CoordinationType.OBS_TYPE,
@@ -1654,6 +1707,13 @@ const COMPONENT_COORDINATION_TYPES = {
     CoordinationType.OBS_SET_SELECTION,
     CoordinationType.OBS_SET_FILTER
   ],
+  [ViewType.SAMPLE_SET_PAIR_MANAGER]: [
+    CoordinationType.DATASET,
+    CoordinationType.OBS_TYPE,
+    CoordinationType.SAMPLE_TYPE,
+    CoordinationType.SAMPLE_SET_SELECTION,
+    CoordinationType.SAMPLE_SET_FILTER
+  ],
   [ViewType.TREEMAP]: [
     CoordinationType.DATASET,
     CoordinationType.OBS_TYPE,
@@ -2022,7 +2082,7 @@ object-assign
 @license MIT
 */
 var getOwnPropertySymbols$1 = Object.getOwnPropertySymbols;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwnProperty$9 = Object.prototype.hasOwnProperty;
 var propIsEnumerable = Object.prototype.propertyIsEnumerable;
 function toObject(val) {
   if (val === null || val === void 0) {
@@ -2069,7 +2129,7 @@ var objectAssign = shouldUseNative() ? Object.assign : function(target, source)
   for (var s = 1; s < arguments.length; s++) {
     from = Object(arguments[s]);
     for (var key in from) {
-      if (hasOwnProperty.call(from, key)) {
+      if (hasOwnProperty$9.call(from, key)) {
         to2[key] = from[key];
       }
     }
@@ -3102,7 +3162,7 @@ function _objectWithoutProperties(source, excluded) {
   }
   return target;
 }
-var keys = ["xs", "sm", "md", "lg", "xl"];
+var keys$1 = ["xs", "sm", "md", "lg", "xl"];
 function createBreakpoints(breakpoints) {
   var _breakpoints$values = breakpoints.values, values2 = _breakpoints$values === void 0 ? {
     xs: 0,
@@ -3116,20 +3176,20 @@ function createBreakpoints(breakpoints) {
     return "@media (min-width:".concat(value).concat(unit, ")");
   }
   function down(key) {
-    var endIndex = keys.indexOf(key) + 1;
-    var upperbound = values2[keys[endIndex]];
-    if (endIndex === keys.length) {
+    var endIndex = keys$1.indexOf(key) + 1;
+    var upperbound = values2[keys$1[endIndex]];
+    if (endIndex === keys$1.length) {
       return up2("xs");
     }
     var value = typeof upperbound === "number" && endIndex > 0 ? upperbound : key;
     return "@media (max-width:".concat(value - step / 100).concat(unit, ")");
   }
   function between(start, end) {
-    var endIndex = keys.indexOf(end);
-    if (endIndex === keys.length - 1) {
+    var endIndex = keys$1.indexOf(end);
+    if (endIndex === keys$1.length - 1) {
       return up2(start);
     }
-    return "@media (min-width:".concat(typeof values2[start] === "number" ? values2[start] : start).concat(unit, ") and ") + "(max-width:".concat((endIndex !== -1 && typeof values2[keys[endIndex + 1]] === "number" ? values2[keys[endIndex + 1]] : end) - step / 100).concat(unit, ")");
+    return "@media (min-width:".concat(typeof values2[start] === "number" ? values2[start] : start).concat(unit, ") and ") + "(max-width:".concat((endIndex !== -1 && typeof values2[keys$1[endIndex + 1]] === "number" ? values2[keys$1[endIndex + 1]] : end) - step / 100).concat(unit, ")");
   }
   function only(key) {
     return between(key, key);
@@ -3145,7 +3205,7 @@ function createBreakpoints(breakpoints) {
     return values2[key];
   }
   return _extends$2({
-    keys,
+    keys: keys$1,
     values: values2,
     up: up2,
     down,
@@ -3959,7 +4019,7 @@ function createUnarySpacing(theme) {
     return void 0;
   };
 }
-function getValue(transformer, propValue) {
+function getValue$1(transformer, propValue) {
   if (typeof propValue === "string" || propValue == null) {
     return propValue;
   }
@@ -3976,7 +4036,7 @@ function getValue(transformer, propValue) {
 function getStyleFromPropValue(cssProperties, transformer) {
   return function(propValue) {
     return cssProperties.reduce(function(acc, cssProperty) {
-      acc[cssProperty] = getValue(transformer, propValue);
+      acc[cssProperty] = getValue$1(transformer, propValue);
       return acc;
     }, {});
   };
@@ -7325,7 +7385,7 @@ function styled$2(Component) {
     }
     var stylesOrCreator = typeof style === "function" ? function(theme) {
       return {
-        root: function root(props) {
+        root: function root2(props) {
           return style(_extends$2({
             theme
           }, props));
@@ -17751,7 +17811,7 @@ function taskDebounce(fn2) {
 }
 var supportsMicroTasks = isBrowser && window.Promise;
 var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
-function isFunction(functionToCheck) {
+function isFunction$1(functionToCheck) {
   var getType = {};
   return functionToCheck && getType.toString.call(functionToCheck) === "[object Function]";
 }
@@ -18209,7 +18269,7 @@ function runModifiers(modifiers2, data, ends) {
       console.warn("`modifier.function` is deprecated, use `modifier.fn`!");
     }
     var fn2 = modifier["function"] || modifier.fn;
-    if (modifier.enabled && isFunction(fn2)) {
+    if (modifier.enabled && isFunction$1(fn2)) {
       data.offsets.popper = getClientRect(data.offsets.popper);
       data.offsets.reference = getClientRect(data.offsets.reference);
       data = fn2(data, modifier);
@@ -19172,7 +19232,7 @@ var Popper$1 = function() {
       return a.order - b.order;
     });
     this.modifiers.forEach(function(modifierOptions) {
-      if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {
+      if (modifierOptions.enabled && isFunction$1(modifierOptions.onLoad)) {
         modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);
       }
     });
@@ -22462,7 +22522,7 @@ const ExpandMoreIcon = createSvgIcon(/* @__PURE__ */ React.createElement("path",
 const InfoIcon = createSvgIcon(/* @__PURE__ */ React.createElement("path", {
   d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-6h2v6zm0-8h-2V7h2v2z"
 }), "Info");
-const useStyles$1 = makeStyles(() => ({
+const useStyles$2 = makeStyles(() => ({
   header: {
     marginTop: "10px",
     marginBottom: "10px"
@@ -22505,7 +22565,7 @@ function ConfirmatoryCart(props) {
     // eslint-disable-next-line no-unused-vars
     setCurrentStratificationSelection
   } = props;
-  const classes = useStyles$1();
+  const classes = useStyles$2();
   const [expandedAccordions, setExpandedAccordions] = React__default.useState([
     "agnostic",
     "specific",
@@ -24098,7 +24158,7 @@ const Autocomplete$1 = withStyles2(styles42, {
 var safeIsNaN = Number.isNaN || function ponyfill(value) {
   return typeof value === "number" && value !== value;
 };
-function isEqual(first, second) {
+function isEqual$1(first, second) {
   if (first === second) {
     return true;
   }
@@ -24112,7 +24172,7 @@ function areInputsEqual(newInputs, lastInputs) {
     return false;
   }
   for (var i = 0; i < newInputs.length; i++) {
-    if (!isEqual(newInputs[i], lastInputs[i])) {
+    if (!isEqual$1(newInputs[i], lastInputs[i])) {
       return false;
     }
   }
@@ -24767,7 +24827,7 @@ function SelectAgnostic(props) {
     currentModalityAgnosticSelection,
     setCurrentModalityAgnosticSelection
   } = props;
-  const classes = useStyles$1();
+  const classes = useStyles$2();
   const [selectedItem, setSelectedItem] = React__default.useState(null);
   const [potentialItems, setPotentialItems] = React__default.useState([]);
   const handleChange = async (event) => {
@@ -30750,7 +30810,7 @@ function SelectSpecific(props) {
     setCurrentModalitySpecificSelection,
     getEdges
   } = props;
-  const classes = useStyles$1();
+  const classes = useStyles$2();
   const queries = useQueries({
     queries: (currentModalityAgnosticSelection == null ? void 0 : currentModalityAgnosticSelection.map((item) => ({
       queryKey: [item.nodeType, item.kgId],
@@ -30886,7 +30946,7 @@ function ConfirmatoryStepper(props) {
     stratifications,
     onFinish
   } = props;
-  const classes = useStyles$1();
+  const classes = useStyles$2();
   const [activeStep, setActiveStep] = React__default.useState(0);
   const [skipped, setSkipped] = React__default.useState(/* @__PURE__ */ new Set());
   const isStepOptional = (step) => step === 2;
@@ -31028,7 +31088,7 @@ function ExploratoryStepper(props) {
     stratifications,
     onFinish
   } = props;
-  const classes = useStyles$1();
+  const classes = useStyles$2();
   const [activeStep, setActiveStep] = React__default.useState(0);
   const [skipped, setSkipped] = React__default.useState(/* @__PURE__ */ new Set());
   const isStepOptional = (step) => step === 2;
@@ -31141,7 +31201,7 @@ function ScmdUi(props) {
     stratifications,
     onFinish
   } = props;
-  const classes = useStyles$1();
+  const classes = useStyles$2();
   const mode = modeProp || "confirmatory";
   const [tempIsVisible, setTempIsVisible] = useState(true);
   const isConfirmatoryMode = mode === "confirmatory";
@@ -31309,14 +31369,21 @@ function BiomarkerSelectSubscriber(props) {
     }
   ) : null });
 }
-const useStyles = makeStyles((theme) => ({
+const useStyles$1 = makeStyles((theme) => ({
   buttonContainer: {
     position: "absolute",
     right: 0,
     display: "flex",
     flexDirection: "column",
     justifyContent: "center",
-    height: "100%"
+    height: "100%",
+    "& div": {
+      display: "flex",
+      flexDirection: "row"
+    },
+    "& div > button": {
+      height: "auto"
+    }
   },
   headingContainer: {
     backgroundColor: "transparent"
@@ -31341,14 +31408,13 @@ function ComparativeHeadingSubscriber(props) {
     sampleSetSelection,
     featureSelection
   }, {
-    setSampleSetSelection
-    // TODO: buttons for modification of featureSelection
-    // setFeatureSelection,
+    setSampleSetSelection,
+    setFeatureSelection
   }] = useCoordination(
     COMPONENT_COORDINATION_TYPES[ViewType.COMPARATIVE_HEADING],
     coordinationScopes
   );
-  const classes = useStyles();
+  const classes = useStyles$1();
   const swapSampleSets = useCallback(() => {
     if ((sampleSetSelection == null ? void 0 : sampleSetSelection.length) === 2) {
       setSampleSetSelection([
@@ -31357,22 +31423,874 @@ function ComparativeHeadingSubscriber(props) {
       ]);
     }
   }, [sampleSetSelection, setSampleSetSelection]);
+  const clearSampleSetSelection = useCallback(() => {
+    if ((sampleSetSelection == null ? void 0 : sampleSetSelection.length) === 2) {
+      setSampleSetSelection(null);
+    }
+  }, [sampleSetSelection, setSampleSetSelection]);
+  const clearFeatureSelection = useCallback(() => {
+    if (Array.isArray(featureSelection) && featureSelection.length > 0) {
+      setFeatureSelection(null);
+    }
+  }, [featureSelection, setFeatureSelection]);
   return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: classes.headingContainer, children: [
     sampleSetSelection && sampleSetSelection.length === 2 ? /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: classes.headingSectionContainer, children: [
       /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { width: "45%" }, children: /* @__PURE__ */ jsxRuntimeExports.jsx("h2", { className: classes.headingText, children: (_a2 = sampleSetSelection == null ? void 0 : sampleSetSelection[0]) == null ? void 0 : _a2.at(-1) }) }),
       /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { width: "5%" }, children: /* @__PURE__ */ jsxRuntimeExports.jsx("h2", { className: classes.headingText, style: { textAlign: "right" }, children: "vs. " }) }),
       /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { width: "50%" }, children: /* @__PURE__ */ jsxRuntimeExports.jsx("h2", { className: classes.headingText, children: (_b = sampleSetSelection == null ? void 0 : sampleSetSelection[1]) == null ? void 0 : _b.at(-1) }) }),
-      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: classes.buttonContainer, children: /* @__PURE__ */ jsxRuntimeExports.jsx("button", { onClick: swapSampleSets, type: "button", children: "Swap" }) })
-    ] }) : null,
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: classes.buttonContainer, children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("button", { onClick: swapSampleSets, type: "button", children: "Swap" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("button", { onClick: clearSampleSetSelection, type: "button", children: "Clear" })
+      ] }) })
+    ] }) : /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: classes.headingSectionContainer, children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: /* @__PURE__ */ jsxRuntimeExports.jsx("h2", { className: classes.headingText, children: "All samples" }) }) }),
     featureSelection && featureSelection.length > 0 ? /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: classes.headingSectionContainer, children: [
       /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: /* @__PURE__ */ jsxRuntimeExports.jsx("h3", { className: classes.headingText, children: "Selected Biomarkers: " }) }),
       featureSelection == null ? void 0 : featureSelection.map((featureName, i) => /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: /* @__PURE__ */ jsxRuntimeExports.jsxs("h3", { className: classes.headingText, children: [
         featureName,
         i < featureSelection.length - 1 ? /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: ", " }) : null
-      ] }) }))
+      ] }) }, featureName)),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: classes.buttonContainer, children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: /* @__PURE__ */ jsxRuntimeExports.jsx("button", { onClick: clearFeatureSelection, type: "button", children: "Clear" }) }) })
     ] }) : null
   ] });
 }
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+const freeGlobal$1 = freeGlobal;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal$1 || freeSelf || Function("return this")();
+const root$1 = root;
+var Symbol$1 = root$1.Symbol;
+const Symbol$2 = Symbol$1;
+var objectProto$b = Object.prototype;
+var hasOwnProperty$8 = objectProto$b.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$b.toString;
+var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty$8.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var objectProto$a = Object.prototype;
+var nativeObjectToString = objectProto$a.toString;
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$2 ? Symbol$2.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function isObjectLike$1(value) {
+  return value != null && typeof value == "object";
+}
+var isArray$1 = Array.isArray;
+const isArray$2 = isArray$1;
+function isObject$1(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var asyncTag = "[object AsyncFunction]", funcTag$1 = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject$1(value)) {
+    return false;
+  }
+  var tag = baseGetTag(value);
+  return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var coreJsData = root$1["__core-js_shared__"];
+const coreJsData$1 = coreJsData;
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData$1 && coreJsData$1.keys && coreJsData$1.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var funcProto$1 = Function.prototype;
+var funcToString$1 = funcProto$1.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype, objectProto$9 = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString.call(hasOwnProperty$7).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative(value) {
+  if (!isObject$1(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var WeakMap$1 = getNative(root$1, "WeakMap");
+const WeakMap$2 = WeakMap$1;
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER$1 : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+function isArrayLike(value) {
+  return value != null && isLength(value.length) && !isFunction(value);
+}
+var objectProto$8 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$8;
+  return value === proto;
+}
+function baseTimes(n2, iteratee) {
+  var index = -1, result = Array(n2);
+  while (++index < n2) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+var argsTag$2 = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike$1(value) && baseGetTag(value) == argsTag$2;
+}
+var objectProto$7 = Object.prototype;
+var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
+var propertyIsEnumerable$1 = objectProto$7.propertyIsEnumerable;
+var isArguments = baseIsArguments(function() {
+  return arguments;
+}()) ? baseIsArguments : function(value) {
+  return isObjectLike$1(value) && hasOwnProperty$6.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
+};
+const isArguments$1 = isArguments;
+function stubFalse() {
+  return false;
+}
+var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+var Buffer = moduleExports$1 ? root$1.Buffer : void 0;
+var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+var isBuffer = nativeIsBuffer || stubFalse;
+const isBuffer$1 = isBuffer;
+var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$1 = "[object Error]", funcTag = "[object Function]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", objectTag$2 = "[object Object]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", weakMapTag$1 = "[object WeakMap]";
+var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$2 = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag$1] = typedArrayTags[boolTag$1] = typedArrayTags[dataViewTag$2] = typedArrayTags[dateTag$1] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag] = typedArrayTags[mapTag$2] = typedArrayTags[numberTag$1] = typedArrayTags[objectTag$2] = typedArrayTags[regexpTag$1] = typedArrayTags[setTag$2] = typedArrayTags[stringTag$1] = typedArrayTags[weakMapTag$1] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike$1(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var freeProcess = moduleExports && freeGlobal$1.process;
+var nodeUtil = function() {
+  try {
+    var types = freeModule && freeModule.require && freeModule.require("util").types;
+    if (types) {
+      return types;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {
+  }
+}();
+const nodeUtil$1 = nodeUtil;
+var nodeIsTypedArray = nodeUtil$1 && nodeUtil$1.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+const isTypedArray$1 = isTypedArray;
+var objectProto$6 = Object.prototype;
+var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray$2(value), isArg = !isArr && isArguments$1(value), isBuff = !isArr && !isArg && isBuffer$1(value), isType = !isArr && !isArg && !isBuff && isTypedArray$1(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if ((inherited || hasOwnProperty$5.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+    isIndex(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+function overArg(func, transform3) {
+  return function(arg) {
+    return func(transform3(arg));
+  };
+}
+var nativeKeys = overArg(Object.keys, Object);
+const nativeKeys$1 = nativeKeys;
+var objectProto$5 = Object.prototype;
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys$1(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty$4.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+function keys(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+var nativeCreate = getNative(Object, "create");
+const nativeCreate$1 = nativeCreate;
+function hashClear() {
+  this.__data__ = nativeCreate$1 ? nativeCreate$1(null) : {};
+  this.size = 0;
+}
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
+var objectProto$4 = Object.prototype;
+var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate$1) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$2 ? void 0 : result;
+  }
+  return hasOwnProperty$3.call(data, key) ? data[key] : void 0;
+}
+var objectProto$3 = Object.prototype;
+var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate$1 ? data[key] !== void 0 : hasOwnProperty$2.call(data, key);
+}
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate$1 && value === void 0 ? HASH_UNDEFINED$1 : value;
+  return this;
+}
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = hashClear;
+Hash.prototype["delete"] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+function listCacheGet(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+function listCacheSet(key, value) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype["delete"] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+var Map$1 = getNative(root$1, "Map");
+const Map$2 = Map$1;
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map$2 || ListCache)(),
+    "string": new Hash()
+  };
+}
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+function mapCacheDelete(key) {
+  var result = getMapData(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+function mapCacheSet(key, value) {
+  var data = getMapData(this, key), size2 = data.size;
+  data.set(key, value);
+  this.size += data.size == size2 ? 0 : 1;
+  return this;
+}
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype["delete"] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+function arrayPush(array, values2) {
+  var index = -1, length = values2.length, offset2 = array.length;
+  while (++index < length) {
+    array[offset2 + index] = values2[index];
+  }
+  return array;
+}
+function stackClear() {
+  this.__data__ = new ListCache();
+  this.size = 0;
+}
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache) {
+    var pairs = data.__data__;
+    if (!Map$2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+Stack.prototype.clear = stackClear;
+Stack.prototype["delete"] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+function arrayFilter(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+function stubArray() {
+  return [];
+}
+var objectProto$2 = Object.prototype;
+var propertyIsEnumerable = objectProto$2.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+const getSymbols$1 = getSymbols;
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray$2(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+function getAllKeys(object) {
+  return baseGetAllKeys(object, keys, getSymbols$1);
+}
+var DataView = getNative(root$1, "DataView");
+const DataView$1 = DataView;
+var Promise$1 = getNative(root$1, "Promise");
+const Promise$2 = Promise$1;
+var Set$1 = getNative(root$1, "Set");
+const Set$2 = Set$1;
+var mapTag$1 = "[object Map]", objectTag$1 = "[object Object]", promiseTag = "[object Promise]", setTag$1 = "[object Set]", weakMapTag = "[object WeakMap]";
+var dataViewTag$1 = "[object DataView]";
+var dataViewCtorString = toSource(DataView$1), mapCtorString = toSource(Map$2), promiseCtorString = toSource(Promise$2), setCtorString = toSource(Set$2), weakMapCtorString = toSource(WeakMap$2);
+var getTag$1 = baseGetTag;
+if (DataView$1 && getTag$1(new DataView$1(new ArrayBuffer(1))) != dataViewTag$1 || Map$2 && getTag$1(new Map$2()) != mapTag$1 || Promise$2 && getTag$1(Promise$2.resolve()) != promiseTag || Set$2 && getTag$1(new Set$2()) != setTag$1 || WeakMap$2 && getTag$1(new WeakMap$2()) != weakMapTag) {
+  getTag$1 = function(value) {
+    var result = baseGetTag(value), Ctor = result == objectTag$1 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag$1;
+        case mapCtorString:
+          return mapTag$1;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag$1;
+        case weakMapCtorString:
+          return weakMapTag;
+      }
+    }
+    return result;
+  };
+}
+const getTag$2 = getTag$1;
+var Uint8Array$1 = root$1.Uint8Array;
+const Uint8Array$2 = Uint8Array$1;
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+function SetCache(values2) {
+  var index = -1, length = values2 == null ? 0 : values2.length;
+  this.__data__ = new MapCache();
+  while (++index < length) {
+    this.add(values2[index]);
+  }
+}
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+function arraySome(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+function cacheHas(cache2, key) {
+  return cache2.has(key);
+}
+var COMPARE_PARTIAL_FLAG$3 = 1, COMPARE_UNORDERED_FLAG$1 = 2;
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, arrLength = array.length, othLength = other.length;
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$1 ? new SetCache() : void 0;
+  stack.set(array, other);
+  stack.set(other, array);
+  while (++index < arrLength) {
+    var arrValue = array[index], othValue = other[index];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== void 0) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    if (seen) {
+      if (!arraySome(other, function(othValue2, othIndex) {
+        if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+          return seen.push(othIndex);
+        }
+      })) {
+        result = false;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+      result = false;
+      break;
+    }
+  }
+  stack["delete"](array);
+  stack["delete"](other);
+  return result;
+}
+function mapToArray(map) {
+  var index = -1, result = Array(map.size);
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+function setToArray(set2) {
+  var index = -1, result = Array(set2.size);
+  set2.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+var COMPARE_PARTIAL_FLAG$2 = 1, COMPARE_UNORDERED_FLAG = 2;
+var boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", mapTag = "[object Map]", numberTag = "[object Number]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]";
+var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]";
+var symbolProto = Symbol$2 ? Symbol$2.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+    case arrayBufferTag:
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array$2(object), new Uint8Array$2(other))) {
+        return false;
+      }
+      return true;
+    case boolTag:
+    case dateTag:
+    case numberTag:
+      return eq(+object, +other);
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+    case regexpTag:
+    case stringTag:
+      return object == other + "";
+    case mapTag:
+      var convert = mapToArray;
+    case setTag:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$2;
+      convert || (convert = setToArray);
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG;
+      stack.set(object, other);
+      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object);
+      return result;
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+var COMPARE_PARTIAL_FLAG$1 = 1;
+var objectProto$1 = Object.prototype;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$1, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty$1.call(other, key))) {
+      return false;
+    }
+  }
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key], othValue = other[key];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+    }
+    if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == "constructor");
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor, othCtor = other.constructor;
+    if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack["delete"](object);
+  stack["delete"](other);
+  return result;
+}
+var COMPARE_PARTIAL_FLAG = 1;
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]";
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray$2(object), othIsArr = isArray$2(other), objTag = objIsArr ? arrayTag : getTag$2(object), othTag = othIsArr ? arrayTag : getTag$2(other);
+  objTag = objTag == argsTag ? objectTag : objTag;
+  othTag = othTag == argsTag ? objectTag : othTag;
+  var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer$1(object)) {
+    if (!isBuffer$1(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack());
+    return objIsArr || isTypedArray$1(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+    var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+      stack || (stack = new Stack());
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack());
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || !isObjectLike$1(value) && !isObjectLike$1(other)) {
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+function isEqual(value, other) {
+  return baseIsEqual(value, other);
+}
+const useStyles = makeStyles(() => ({
+  selectedPair: {
+    fontWeight: "bold"
+  },
+  pairUl: {
+    paddingLeft: "15px",
+    marginTop: 0,
+    fontSize: "12px",
+    "& button": {
+      fontSize: "12px"
+    }
+  }
+}));
+function SampleSetPairManagerSubscriber(props) {
+  const {
+    coordinationScopes,
+    removeGridComponent,
+    theme,
+    title = "Sample Sets",
+    closeButtonVisible,
+    helpText = ViewHelpMapping.SAMPLE_SET_PAIR_MANAGER
+  } = props;
+  const classes = useStyles();
+  const loaders = useLoaders();
+  const [{
+    dataset,
+    obsType,
+    sampleType,
+    sampleSetSelection
+  }, {
+    setSampleSetSelection
+  }] = useCoordination(
+    COMPONENT_COORDINATION_TYPES[ViewType.SAMPLE_SET_PAIR_MANAGER],
+    coordinationScopes
+  );
+  const sampleSetsLoader = useMatchingLoader(
+    loaders,
+    dataset,
+    DataType.SAMPLE_SETS,
+    { sampleType }
+  );
+  const sampleSetsColumnNameMappingReversed = useColumnNameMapping(sampleSetsLoader, true);
+  const [{ comparisonMetadata }, cmpMetadataStatus] = useComparisonMetadata(
+    loaders,
+    dataset,
+    false,
+    {},
+    {},
+    { obsType, sampleType }
+  );
+  const isReady = useReady([
+    cmpMetadataStatus
+  ]);
+  const stratificationOptions = useMemo(() => {
+    if (comparisonMetadata == null ? void 0 : comparisonMetadata.sample_group_pairs) {
+      return comparisonMetadata.sample_group_pairs.map((sampleGroupPair) => {
+        const [sampleGroupCol, sampleGroupValues] = sampleGroupPair;
+        const [sampleGroupCtrl, sampleGroupCase] = sampleGroupValues;
+        const groupName = sampleSetsColumnNameMappingReversed == null ? void 0 : sampleSetsColumnNameMappingReversed[sampleGroupCol];
+        return {
+          stratificationId: `${sampleGroupCol}_${sampleGroupCtrl}-vs-${sampleGroupCase}`,
+          name: `${groupName}: ${sampleGroupCtrl} vs. ${sampleGroupCase}`,
+          stratificationType: "sampleSet",
+          sampleSets: [
+            // With sampleSets coming from the comparison_metadata,
+            // need to use loader options from obsSets and sampleSets to get mapping
+            // from column name to group name.
+            [groupName, sampleGroupCtrl],
+            [groupName, sampleGroupCase]
+          ]
+        };
+      });
+    }
+    return null;
+  }, [comparisonMetadata, sampleSetsColumnNameMappingReversed]);
+  const onSelectPair = useCallback((sampleSetPair) => {
+    setSampleSetSelection(sampleSetPair);
+  }, [sampleSetSelection, setSampleSetSelection]);
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    TitleInfo,
+    {
+      title,
+      closeButtonVisible,
+      removeGridComponent,
+      isScroll: true,
+      theme,
+      isReady,
+      helpText,
+      children: /* @__PURE__ */ jsxRuntimeExports.jsx("ul", { className: classes.pairUl, children: stratificationOptions == null ? void 0 : stratificationOptions.map((pairObj) => {
+        const isSelected = Array.isArray(sampleSetSelection) && sampleSetSelection.length === 2 && (isEqual(pairObj.sampleSets, sampleSetSelection) || isEqual(pairObj.sampleSets, [sampleSetSelection == null ? void 0 : sampleSetSelection[1], sampleSetSelection == null ? void 0 : sampleSetSelection[0]]));
+        return /* @__PURE__ */ jsxRuntimeExports.jsxs(
+          "li",
+          {
+            className: clsx({ [classes.selectedPair]: isSelected }),
+            children: [
+              pairObj.name,
+              " ",
+              !isSelected ? /* @__PURE__ */ jsxRuntimeExports.jsx(
+                "button",
+                {
+                  type: "button",
+                  onClick: () => onSelectPair(pairObj.sampleSets),
+                  children: "Select"
+                }
+              ) : null
+            ]
+          },
+          pairObj.stratificationId
+        );
+      }) })
+    }
+  );
+}
 var EOL = {}, EOF = {}, QUOTE = 34, NEWLINE = 10, RETURN = 13;
 function objectConverter(columns2) {
   return new Function("d", "return {" + columns2.map(function(name, i) {
@@ -32441,12 +33359,17 @@ function loadCellTypeNodes() {
   });
 }
 function loadPathwayNodes() {
-  return fetch(`${KG_BASE_URL}/Reactome_2022.nodes.csv`).then((res) => res.text()).then((res) => {
+  const reactomeNodes = fetch(`${KG_BASE_URL}/Reactome_2022.nodes.csv`);
+  return reactomeNodes.then((res) => res.text()).then((res) => {
     const result = csvParse(res);
     return result.map((d) => ({
       kgId: d.id,
       label: d.pathway,
+      // For reactome
       term: `reactome:${d.acc}`,
+      // For reactome
+      // label: d.ontology_label, // For GO_BP
+      // term: d.acc, // For GO_BP
       nodeType: "pathway"
     }));
   });
@@ -32503,7 +33426,8 @@ async function autocompleteFeature({ queryClient }, partial, targetModality) {
   return results.map((result) => result.item);
 }
 async function loadPathwayToGeneEdges() {
-  return fetch(`${KG_BASE_URL}/Reactome_2022.Reactome.Gene.edges.csv`).then((res) => res.text()).then((res) => {
+  const reactomeEdges = fetch(`${KG_BASE_URL}/Reactome_2022.Reactome.Gene.edges.csv`);
+  return reactomeEdges.then((res) => res.text()).then((res) => {
     const result = csvParse(res);
     return result.map((d) => ({
       source: d.source,
@@ -32572,6 +33496,7 @@ async function getTermMapping({ queryClient }, keyCuriePrefix, valCuriePrefix) {
 export {
   BiomarkerSelectSubscriber,
   ComparativeHeadingSubscriber,
+  SampleSetPairManagerSubscriber,
   autocompleteFeature,
   getAlternativeTerms,
   getTermMapping,