@vitessce/heatmap 3.9.2 → 3.9.4

package/dist/{index-COwftYHh.js → index-CdqVjZrU.js}

@@ -3,7 +3,7 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var _a2, _b;
 import * as React from "react";
-import React__default, { useContext, forwardRef, useRef, useMemo, createContext, createElement, isValidElement, cloneElement, Children, useState, useEffect, useCallback, useLayoutEffect, useImperativeHandle, useReducer } from "react";
+import React__default, { useContext, forwardRef, useRef, useMemo, createContext, createElement, isValidElement, cloneElement, Children, PureComponent, useEffect, useState, useCallback, useLayoutEffect, useImperativeHandle, useReducer } from "react";
 import { useVitessceContainer, useComponentHover, useComponentViewInfo, usePlotOptionsStyles, OptionsContainer, OptionSelect, useLoaders, useCoordinationScopes, useSetComponentHover, useSetComponentViewInfo, useCoordination, useDeckCanvasSize, useMultiObsLabels, useFeatureLabelsData, useExpandedFeatureLabelsMap, useObsFeatureMatrixData, useObsSetsData, useReady, useUrls, useUint8ObsFeatureMatrix, useGetObsInfo, useGetObsMembership, TitleInfo } from "@vitessce/vit-s";
 import * as ReactDOM from "react-dom";
 function _mergeNamespaces(n2, m) {
@@ -1325,9 +1325,9 @@ function mapCacheHas(key) {
   return getMapData(this, key).has(key);
 }
 function mapCacheSet(key, value) {
-  var data = getMapData(this, key), size = data.size;
+  var data = getMapData(this, key), size2 = data.size;
   data.set(key, value);
-  this.size += data.size == size ? 0 : 1;
+  this.size += data.size == size2 ? 0 : 1;
   return this;
 }
 function MapCache(entries) {
@@ -1856,7 +1856,7 @@ function baseIsEqual(value, other, bitmask, customizer, stack2) {
   }
   return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack2);
 }
-var now = function() {
+var now$1 = function() {
   return root$1.Date.now();
 };
 var FUNC_ERROR_TEXT = "Expected a function";
@@ -1894,7 +1894,7 @@ function debounce$1(func, wait, options) {
     return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
   }
   function timerExpired() {
-    var time = now();
+    var time = now$1();
     if (shouldInvoke(time)) {
       return trailingEdge(time);
     }
@@ -1916,10 +1916,10 @@ function debounce$1(func, wait, options) {
     lastArgs = lastCallTime = lastThis = timerId = void 0;
   }
   function flush() {
-    return timerId === void 0 ? result : trailingEdge(now());
+    return timerId === void 0 ? result : trailingEdge(now$1());
   }
   function debounced() {
-    var time = now(), isInvoking = shouldInvoke(time);
+    var time = now$1(), isInvoking = shouldInvoke(time);
     lastArgs = arguments;
     lastThis = this;
     lastCallTime = time;
@@ -1942,7 +1942,7 @@ function debounce$1(func, wait, options) {
   debounced.flush = flush;
   return debounced;
 }
-function isEqual$1(value, other) {
+function isEqual$2(value, other) {
   return baseIsEqual(value, other);
 }
 function isNil(value) {
@@ -5929,8 +5929,8 @@ class ZodSet extends ZodType {
       maxSize: { value: maxSize, message: errorUtil.toString(message) }
     });
   }
-  size(size, message) {
-    return this.min(size, message).max(size, message);
+  size(size2, message) {
+    return this.min(size2, message).max(size2, message);
   }
   nonempty(message) {
     return this.min(1, message);
@@ -9544,6 +9544,7 @@ const ViewType$1 = {
   OBS_SET_COMPOSITION_BAR_PLOT: "obsSetCompositionBarPlot",
   FEATURE_SET_ENRICHMENT_BAR_PLOT: "featureSetEnrichmentBarPlot",
   BIOMARKER_SELECT: "biomarkerSelect",
+  BIOMARKER_SELECT_ALT: "biomarkerSelectAlt",
   COMPARATIVE_HEADING: "comparativeHeading",
   LINK_CONTROLLER: "linkController",
   NEUROGLANCER: "neuroglancer",
@@ -10741,6 +10742,17 @@ const COMPONENT_COORDINATION_TYPES = {
     CoordinationType$1.OBS_SET_FILTER
     // TODO: create coordination types for internal state of the biomarker selection view?
   ],
+  [ViewType$1.BIOMARKER_SELECT_ALT]: [
+    CoordinationType$1.DATASET,
+    CoordinationType$1.OBS_TYPE,
+    CoordinationType$1.SAMPLE_TYPE,
+    CoordinationType$1.FEATURE_SELECTION,
+    CoordinationType$1.SAMPLE_SET_SELECTION,
+    CoordinationType$1.SAMPLE_SET_FILTER,
+    CoordinationType$1.OBS_SET_SELECTION,
+    CoordinationType$1.OBS_SET_FILTER
+    // TODO: create coordination types for internal state of the biomarker selection view?
+  ],
   [ViewType$1.COMPARATIVE_HEADING]: [
     CoordinationType$1.DATASET,
     CoordinationType$1.OBS_TYPE,
@@ -11943,11 +11955,11 @@ function requireTinycolor() {
         var bestColor = null;
         var bestScore = 0;
         var readability;
-        var includeFallbackColors, level, size;
+        var includeFallbackColors, level, size2;
         args = args || {};
         includeFallbackColors = args.includeFallbackColors;
         level = args.level;
-        size = args.size;
+        size2 = args.size;
         for (var i2 = 0; i2 < colorList.length; i2++) {
           readability = tinycolor2.readability(baseColor, colorList[i2]);
           if (readability > bestScore) {
@@ -11955,7 +11967,7 @@ function requireTinycolor() {
             bestColor = tinycolor2(colorList[i2]);
           }
         }
-        if (tinycolor2.isReadable(baseColor, bestColor, { "level": level, "size": size }) || !includeFallbackColors) {
+        if (tinycolor2.isReadable(baseColor, bestColor, { "level": level, "size": size2 }) || !includeFallbackColors) {
           return bestColor;
         } else {
           args.includeFallbackColors = false;
@@ -12259,17 +12271,17 @@ function requireTinycolor() {
         return false;
       }
       function validateWCAG2Parms(parms) {
-        var level, size;
+        var level, size2;
         parms = parms || { "level": "AA", "size": "small" };
         level = (parms.level || "AA").toUpperCase();
-        size = (parms.size || "small").toLowerCase();
+        size2 = (parms.size || "small").toLowerCase();
         if (level !== "AA" && level !== "AAA") {
           level = "AA";
         }
-        if (size !== "small" && size !== "large") {
-          size = "small";
+        if (size2 !== "small" && size2 !== "large") {
+          size2 = "small";
         }
-        return { "level": level, "size": size };
+        return { "level": level, "size": size2 };
       }
       if (module2.exports) {
         module2.exports = tinycolor2;
@@ -12336,7 +12348,7 @@ function treeToCellColorsBySetNames(currTree, selectedNamePaths, cellSetColor, t
     const node2 = treeFindNodeByNamePath(currTree, setNamePath);
     if (node2) {
       const nodeSet = nodeToSet(node2);
-      const nodeColor = ((_a3 = cellSetColor == null ? void 0 : cellSetColor.find((d) => isEqual$1(d.path, setNamePath))) == null ? void 0 : _a3.color) || getDefaultColor(theme);
+      const nodeColor = ((_a3 = cellSetColor == null ? void 0 : cellSetColor.find((d) => isEqual$2(d.path, setNamePath))) == null ? void 0 : _a3.color) || getDefaultColor(theme);
       cellColorsArray = [
         ...cellColorsArray,
         ...nodeSet.map(([cellId, prob]) => [
@@ -12978,41 +12990,41 @@ function requireJson2csv_umd() {
         Buffer3.prototype.__proto__ = Uint8Array.prototype;
         Buffer3.__proto__ = Uint8Array;
       }
-      function assertSize(size) {
-        if (typeof size !== "number") {
+      function assertSize(size2) {
+        if (typeof size2 !== "number") {
           throw new TypeError('"size" argument must be a number');
-        } else if (size < 0) {
+        } else if (size2 < 0) {
           throw new RangeError('"size" argument must not be negative');
         }
       }
-      function alloc2(that, size, fill, encoding) {
-        assertSize(size);
-        if (size <= 0) {
-          return createBuffer(that, size);
+      function alloc2(that, size2, fill, encoding) {
+        assertSize(size2);
+        if (size2 <= 0) {
+          return createBuffer(that, size2);
         }
         if (fill !== void 0) {
-          return typeof encoding === "string" ? createBuffer(that, size).fill(fill, encoding) : createBuffer(that, size).fill(fill);
+          return typeof encoding === "string" ? createBuffer(that, size2).fill(fill, encoding) : createBuffer(that, size2).fill(fill);
         }
-        return createBuffer(that, size);
+        return createBuffer(that, size2);
       }
-      Buffer3.alloc = function(size, fill, encoding) {
-        return alloc2(null, size, fill, encoding);
+      Buffer3.alloc = function(size2, fill, encoding) {
+        return alloc2(null, size2, fill, encoding);
       };
-      function allocUnsafe(that, size) {
-        assertSize(size);
-        that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);
+      function allocUnsafe(that, size2) {
+        assertSize(size2);
+        that = createBuffer(that, size2 < 0 ? 0 : checked(size2) | 0);
         if (!Buffer3.TYPED_ARRAY_SUPPORT) {
-          for (var i2 = 0; i2 < size; ++i2) {
+          for (var i2 = 0; i2 < size2; ++i2) {
             that[i2] = 0;
           }
         }
         return that;
       }
-      Buffer3.allocUnsafe = function(size) {
-        return allocUnsafe(null, size);
+      Buffer3.allocUnsafe = function(size2) {
+        return allocUnsafe(null, size2);
       };
-      Buffer3.allocUnsafeSlow = function(size) {
-        return allocUnsafe(null, size);
+      Buffer3.allocUnsafeSlow = function(size2) {
+        return allocUnsafe(null, size2);
       };
       function fromString(that, string2, encoding) {
         if (typeof encoding !== "string" || encoding === "") {
@@ -14366,8 +14378,8 @@ function requireJson2csv_umd() {
       Item.prototype.run = function() {
         this.fun.apply(null, this.array);
       };
-      var performance = global$1.performance || {};
-      performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow || function() {
+      var performance2 = global$1.performance || {};
+      performance2.now || performance2.mozNow || performance2.msNow || performance2.oNow || performance2.webkitNow || function() {
         return (/* @__PURE__ */ new Date()).getTime();
       };
       var inherits;
@@ -14902,11 +14914,11 @@ function requireJson2csv_umd() {
         var end = charStr.length - 1;
         var charCode = charStr.charCodeAt(end);
         if (charCode >= 55296 && charCode <= 56319) {
-          var size = this.surrogateSize;
-          this.charLength += size;
-          this.charReceived += size;
-          this.charBuffer.copy(this.charBuffer, size, 0, size);
-          buffer.copy(this.charBuffer, 0, 0, size);
+          var size2 = this.surrogateSize;
+          this.charLength += size2;
+          this.charReceived += size2;
+          this.charBuffer.copy(this.charBuffer, size2, 0, size2);
+          buffer.copy(this.charBuffer, 0, 0, size2);
           return charStr.substring(0, end);
         }
         return charStr;
@@ -16853,27 +16865,27 @@ function requireJson2csv_umd() {
         this.stringBuffer[this.stringBufferOffset++] = char2;
       };
       proto.appendStringBuf = function(buf, start, end) {
-        var size = buf.length;
+        var size2 = buf.length;
         if (typeof start === "number") {
           if (typeof end === "number") {
             if (end < 0) {
-              size = buf.length - start + end;
+              size2 = buf.length - start + end;
             } else {
-              size = end - start;
+              size2 = end - start;
             }
           } else {
-            size = buf.length - start;
+            size2 = buf.length - start;
           }
         }
-        if (size < 0) {
-          size = 0;
+        if (size2 < 0) {
+          size2 = 0;
         }
-        if (this.stringBufferOffset + size > STRING_BUFFER_SIZE) {
+        if (this.stringBufferOffset + size2 > STRING_BUFFER_SIZE) {
           this.string += this.stringBuffer.toString("utf8", 0, this.stringBufferOffset);
           this.stringBufferOffset = 0;
         }
         buf.copy(this.stringBuffer, this.stringBufferOffset, start, end);
-        this.stringBufferOffset += size;
+        this.stringBufferOffset += size2;
       };
       proto.write = function(buffer) {
         if (typeof buffer === "string") buffer = new Buffer3(buffer);
@@ -18961,9 +18973,9 @@ function parse$4(value, root2, parent, rule, rules, rulesets, pseudo, points, de
 function ruleset(value, root2, parent, index2, offset2, rules, points, type, props, children2, length2) {
   var post = offset2 - 1;
   var rule = offset2 === 0 ? rules : [""];
-  var size = sizeof(rule);
+  var size2 = sizeof(rule);
   for (var i2 = 0, j = 0, k = 0; i2 < index2; ++i2)
-    for (var x = 0, y = substr(value, post + 1, post = abs$1(j = points[i2])), z2 = value; x < size; ++x)
+    for (var x = 0, y = substr(value, post + 1, post = abs$1(j = points[i2])), z2 = value; x < size2; ++x)
       if (z2 = trim(j > 0 ? rule[x] + " " + y : replace(y, /&\f/g, rule[x])))
         props[k++] = z2;
   return node(value, root2, parent, offset2 === 0 ? RULESET : type, props, children2, length2);
@@ -22946,6 +22958,56 @@ const systemDefaultTheme$1 = createTheme$1();
 function useTheme$1(defaultTheme2 = systemDefaultTheme$1) {
   return useTheme$2(defaultTheme2);
 }
+const splitProps = (props) => {
+  var _a3;
+  const result = {
+    systemProps: {},
+    otherProps: {}
+  };
+  const config2 = ((_a3 = props == null ? void 0 : props.theme) == null ? void 0 : _a3.unstable_sxConfig) ?? defaultSxConfig;
+  Object.keys(props).forEach((prop) => {
+    if (config2[prop]) {
+      result.systemProps[prop] = props[prop];
+    } else {
+      result.otherProps[prop] = props[prop];
+    }
+  });
+  return result;
+};
+function extendSxProp$1(props) {
+  const {
+    sx: inSx,
+    ...other
+  } = props;
+  const {
+    systemProps,
+    otherProps
+  } = splitProps(other);
+  let finalSx;
+  if (Array.isArray(inSx)) {
+    finalSx = [systemProps, ...inSx];
+  } else if (typeof inSx === "function") {
+    finalSx = (...args) => {
+      const result = inSx(...args);
+      if (!isPlainObject$1(result)) {
+        return systemProps;
+      }
+      return {
+        ...systemProps,
+        ...result
+      };
+    };
+  } else {
+    finalSx = {
+      ...systemProps,
+      ...inSx
+    };
+  }
+  return {
+    ...otherProps,
+    sx: finalSx
+  };
+}
 const defaultGenerator = (componentName) => componentName;
 const createClassNameGenerator = () => {
   let generate = defaultGenerator;
@@ -24317,17 +24379,17 @@ function createTypography(palette, typography) {
     }
   }
   const coef = fontSize / 14;
-  const pxToRem = pxToRem2 || ((size) => `${size / htmlFontSize * coef}rem`);
-  const buildVariant = (fontWeight, size, lineHeight, letterSpacing, casing) => ({
+  const pxToRem = pxToRem2 || ((size2) => `${size2 / htmlFontSize * coef}rem`);
+  const buildVariant = (fontWeight, size2, lineHeight, letterSpacing, casing) => ({
     fontFamily,
     fontWeight,
-    fontSize: pxToRem(size),
+    fontSize: pxToRem(size2),
     // Unitless following https://meyerweb.com/eric/thoughts/2006/02/08/unitless-line-heights/
     lineHeight,
     // The letter spacing was designed for the Roboto font-family. Using the same letter-spacing
     // across font-families can cause issues with the kerning.
     ...fontFamily === defaultFontFamily ? {
-      letterSpacing: `${round$1(letterSpacing / size)}em`
+      letterSpacing: `${round$1(letterSpacing / size2)}em`
     } : {},
     ...casing,
     ...allVariants
@@ -25138,6 +25200,9 @@ const { tss } = createTss({
   "usePlugin": useMuiThemeStyleOverridesPlugin
 });
 const useStyles$3 = tss.create({});
+function internal_createExtendSxProp() {
+  return extendSxProp$1;
+}
 const memoTheme = unstable_memoTheme;
 ({
   // ┌────────────────────────────── Warning ──────────────────────────────┐
@@ -25160,7 +25225,7 @@ function getSvgIconUtilityClass(slot) {
   return generateUtilityClass("MuiSvgIcon", slot);
 }
 generateUtilityClasses("MuiSvgIcon", ["root", "colorPrimary", "colorSecondary", "colorAction", "colorError", "colorDisabled", "fontSizeInherit", "fontSizeSmall", "fontSizeMedium", "fontSizeLarge"]);
-const useUtilityClasses$7 = (ownerState) => {
+const useUtilityClasses$8 = (ownerState) => {
   const {
     color: color2,
     fontSize,
@@ -25305,7 +25370,7 @@ const SvgIcon = /* @__PURE__ */ React.forwardRef(function SvgIcon2(inProps, ref)
   if (!inheritViewBox) {
     more.viewBox = viewBox;
   }
-  const classes = useUtilityClasses$7(ownerState);
+  const classes = useUtilityClasses$8(ownerState);
   return /* @__PURE__ */ jsxRuntimeExports.jsxs(SvgIconRoot, {
     as: component,
     className: clsx(classes.root, className),
@@ -25951,7 +26016,7 @@ function getPaperUtilityClass(slot) {
   return generateUtilityClass("MuiPaper", slot);
 }
 generateUtilityClasses("MuiPaper", ["root", "rounded", "outlined", "elevation", "elevation0", "elevation1", "elevation2", "elevation3", "elevation4", "elevation5", "elevation6", "elevation7", "elevation8", "elevation9", "elevation10", "elevation11", "elevation12", "elevation13", "elevation14", "elevation15", "elevation16", "elevation17", "elevation18", "elevation19", "elevation20", "elevation21", "elevation22", "elevation23", "elevation24"]);
-const useUtilityClasses$6 = (ownerState) => {
+const useUtilityClasses$7 = (ownerState) => {
   const {
     square,
     elevation,
@@ -26024,7 +26089,7 @@ const Paper = /* @__PURE__ */ React.forwardRef(function Paper2(inProps, ref) {
     square,
     variant
   };
-  const classes = useUtilityClasses$6(ownerState);
+  const classes = useUtilityClasses$7(ownerState);
   {
     if (theme.shadows[elevation] === void 0) {
       console.error([`MUI: The elevation provided <Paper elevation={${elevation}}> is not available in the theme.`, `Please make sure that \`theme.shadows[${elevation}]\` is defined.`].join("\n"));
@@ -26710,7 +26775,7 @@ function getButtonBaseUtilityClass(slot) {
   return generateUtilityClass("MuiButtonBase", slot);
 }
 const buttonBaseClasses = generateUtilityClasses("MuiButtonBase", ["root", "disabled", "focusVisible"]);
-const useUtilityClasses$5 = (ownerState) => {
+const useUtilityClasses$6 = (ownerState) => {
   const {
     disabled,
     focusVisible,
@@ -26926,7 +26991,7 @@ const ButtonBase = /* @__PURE__ */ React.forwardRef(function ButtonBase2(inProps
     tabIndex,
     focusVisible
   };
-  const classes = useUtilityClasses$5(ownerState);
+  const classes = useUtilityClasses$6(ownerState);
   return /* @__PURE__ */ jsxRuntimeExports.jsxs(ButtonBaseRoot, {
     as: ComponentProp,
     className: clsx(classes.root, className),
@@ -27263,7 +27328,7 @@ function getSwitchBaseUtilityClass(slot) {
   return generateUtilityClass("PrivateSwitchBase", slot);
 }
 generateUtilityClasses("PrivateSwitchBase", ["root", "checked", "disabled", "input", "edgeStart", "edgeEnd"]);
-const useUtilityClasses$4 = (ownerState) => {
+const useUtilityClasses$5 = (ownerState) => {
   const {
     classes,
     checked,
@@ -27400,7 +27465,7 @@ const SwitchBase = /* @__PURE__ */ React.forwardRef(function SwitchBase2(props,
     disableFocusRipple,
     edge
   };
-  const classes = useUtilityClasses$4(ownerState);
+  const classes = useUtilityClasses$5(ownerState);
   const externalForwardedProps = {
     slots,
     slotProps: {
@@ -27609,15 +27674,15 @@ function getCheckboxUtilityClass(slot) {
   return generateUtilityClass("MuiCheckbox", slot);
 }
 const checkboxClasses = generateUtilityClasses("MuiCheckbox", ["root", "checked", "disabled", "indeterminate", "colorPrimary", "colorSecondary", "sizeSmall", "sizeMedium"]);
-const useUtilityClasses$3 = (ownerState) => {
+const useUtilityClasses$4 = (ownerState) => {
   const {
     classes,
     indeterminate,
     color: color2,
-    size
+    size: size2
   } = ownerState;
   const slots = {
-    root: ["root", indeterminate && "indeterminate", `color${capitalize(color2)}`, `size${capitalize(size)}`]
+    root: ["root", indeterminate && "indeterminate", `color${capitalize(color2)}`, `size${capitalize(size2)}`]
   };
   const composedClasses = composeClasses(slots, getCheckboxUtilityClass, classes);
   return {
@@ -27702,7 +27767,7 @@ const Checkbox = /* @__PURE__ */ React.forwardRef(function Checkbox2(inProps, re
     indeterminate = false,
     indeterminateIcon: indeterminateIconProp = defaultIndeterminateIcon,
     inputProps,
-    size = "medium",
+    size: size2 = "medium",
     disableRipple = false,
     className,
     slots = {},
@@ -27716,9 +27781,9 @@ const Checkbox = /* @__PURE__ */ React.forwardRef(function Checkbox2(inProps, re
     disableRipple,
     color: color2,
     indeterminate,
-    size
+    size: size2
   };
-  const classes = useUtilityClasses$3(ownerState);
+  const classes = useUtilityClasses$4(ownerState);
   const externalInputProps = slotProps.input ?? inputProps;
   const [RootSlot, rootSlotProps] = useSlot("root", {
     ref,
@@ -27734,10 +27799,10 @@ const Checkbox = /* @__PURE__ */ React.forwardRef(function Checkbox2(inProps, re
     additionalProps: {
       type: "checkbox",
       icon: /* @__PURE__ */ React.cloneElement(icon, {
-        fontSize: icon.props.fontSize ?? size
+        fontSize: icon.props.fontSize ?? size2
       }),
       checkedIcon: /* @__PURE__ */ React.cloneElement(indeterminateIcon, {
-        fontSize: indeterminateIcon.props.fontSize ?? size
+        fontSize: indeterminateIcon.props.fontSize ?? size2
       }),
       disableRipple,
       slots,
@@ -27867,6 +27932,266 @@ Checkbox.propTypes = {
    */
   value: PropTypes.any
 };
+function getTypographyUtilityClass(slot) {
+  return generateUtilityClass("MuiTypography", slot);
+}
+generateUtilityClasses("MuiTypography", ["root", "h1", "h2", "h3", "h4", "h5", "h6", "subtitle1", "subtitle2", "body1", "body2", "inherit", "button", "caption", "overline", "alignLeft", "alignRight", "alignCenter", "alignJustify", "noWrap", "gutterBottom", "paragraph"]);
+const v6Colors = {
+  primary: true,
+  secondary: true,
+  error: true,
+  info: true,
+  success: true,
+  warning: true,
+  textPrimary: true,
+  textSecondary: true,
+  textDisabled: true
+};
+const extendSxProp = internal_createExtendSxProp();
+const useUtilityClasses$3 = (ownerState) => {
+  const {
+    align,
+    gutterBottom,
+    noWrap,
+    paragraph,
+    variant,
+    classes
+  } = ownerState;
+  const slots = {
+    root: ["root", variant, ownerState.align !== "inherit" && `align${capitalize(align)}`, gutterBottom && "gutterBottom", noWrap && "noWrap", paragraph && "paragraph"]
+  };
+  return composeClasses(slots, getTypographyUtilityClass, classes);
+};
+const TypographyRoot = styled("span", {
+  name: "MuiTypography",
+  slot: "Root",
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [styles.root, ownerState.variant && styles[ownerState.variant], ownerState.align !== "inherit" && styles[`align${capitalize(ownerState.align)}`], ownerState.noWrap && styles.noWrap, ownerState.gutterBottom && styles.gutterBottom, ownerState.paragraph && styles.paragraph];
+  }
+})(memoTheme(({
+  theme
+}) => {
+  var _a3;
+  return {
+    margin: 0,
+    variants: [{
+      props: {
+        variant: "inherit"
+      },
+      style: {
+        // Some elements, like <button> on Chrome have default font that doesn't inherit, reset this.
+        font: "inherit",
+        lineHeight: "inherit",
+        letterSpacing: "inherit"
+      }
+    }, ...Object.entries(theme.typography).filter(([variant, value]) => variant !== "inherit" && value && typeof value === "object").map(([variant, value]) => ({
+      props: {
+        variant
+      },
+      style: value
+    })), ...Object.entries(theme.palette).filter(createSimplePaletteValueFilter()).map(([color2]) => ({
+      props: {
+        color: color2
+      },
+      style: {
+        color: (theme.vars || theme).palette[color2].main
+      }
+    })), ...Object.entries(((_a3 = theme.palette) == null ? void 0 : _a3.text) || {}).filter(([, value]) => typeof value === "string").map(([color2]) => ({
+      props: {
+        color: `text${capitalize(color2)}`
+      },
+      style: {
+        color: (theme.vars || theme).palette.text[color2]
+      }
+    })), {
+      props: ({
+        ownerState
+      }) => ownerState.align !== "inherit",
+      style: {
+        textAlign: "var(--Typography-textAlign)"
+      }
+    }, {
+      props: ({
+        ownerState
+      }) => ownerState.noWrap,
+      style: {
+        overflow: "hidden",
+        textOverflow: "ellipsis",
+        whiteSpace: "nowrap"
+      }
+    }, {
+      props: ({
+        ownerState
+      }) => ownerState.gutterBottom,
+      style: {
+        marginBottom: "0.35em"
+      }
+    }, {
+      props: ({
+        ownerState
+      }) => ownerState.paragraph,
+      style: {
+        marginBottom: 16
+      }
+    }]
+  };
+}));
+const defaultVariantMapping = {
+  h1: "h1",
+  h2: "h2",
+  h3: "h3",
+  h4: "h4",
+  h5: "h5",
+  h6: "h6",
+  subtitle1: "h6",
+  subtitle2: "h6",
+  body1: "p",
+  body2: "p",
+  inherit: "p"
+};
+const Typography = /* @__PURE__ */ React.forwardRef(function Typography2(inProps, ref) {
+  const {
+    color: color2,
+    ...themeProps
+  } = useDefaultProps({
+    props: inProps,
+    name: "MuiTypography"
+  });
+  const isSxColor = !v6Colors[color2];
+  const props = extendSxProp({
+    ...themeProps,
+    ...isSxColor && {
+      color: color2
+    }
+  });
+  const {
+    align = "inherit",
+    className,
+    component,
+    gutterBottom = false,
+    noWrap = false,
+    paragraph = false,
+    variant = "body1",
+    variantMapping = defaultVariantMapping,
+    ...other
+  } = props;
+  const ownerState = {
+    ...props,
+    align,
+    color: color2,
+    className,
+    component,
+    gutterBottom,
+    noWrap,
+    paragraph,
+    variant,
+    variantMapping
+  };
+  const Component2 = component || (paragraph ? "p" : variantMapping[variant] || defaultVariantMapping[variant]) || "span";
+  const classes = useUtilityClasses$3(ownerState);
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(TypographyRoot, {
+    as: Component2,
+    ref,
+    className: clsx(classes.root, className),
+    ...other,
+    ownerState,
+    style: {
+      ...align !== "inherit" && {
+        "--Typography-textAlign": align
+      },
+      ...other.style
+    }
+  });
+});
+Typography.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Set the text-align on the component.
+   * @default 'inherit'
+   */
+  align: PropTypes.oneOf(["center", "inherit", "justify", "left", "right"]),
+  /**
+   * The content of the component.
+   */
+  children: PropTypes.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  /**
+   * @ignore
+   */
+  className: PropTypes.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   */
+  color: PropTypes.oneOfType([PropTypes.oneOf(["primary", "secondary", "success", "error", "info", "warning", "textPrimary", "textSecondary", "textDisabled"]), PropTypes.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: PropTypes.elementType,
+  /**
+   * If `true`, the text will have a bottom margin.
+   * @default false
+   */
+  gutterBottom: PropTypes.bool,
+  /**
+   * If `true`, the text will not wrap, but instead will truncate with a text overflow ellipsis.
+   *
+   * Note that text overflow can only happen with block or inline-block level elements
+   * (the element needs to have a width in order to overflow).
+   * @default false
+   */
+  noWrap: PropTypes.bool,
+  /**
+   * If `true`, the element will be a paragraph element.
+   * @default false
+   * @deprecated Use the `component` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  paragraph: PropTypes.bool,
+  /**
+   * @ignore
+   */
+  style: PropTypes.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  /**
+   * Applies the theme typography styles.
+   * @default 'body1'
+   */
+  variant: PropTypes.oneOfType([PropTypes.oneOf(["body1", "body2", "button", "caption", "h1", "h2", "h3", "h4", "h5", "h6", "inherit", "overline", "subtitle1", "subtitle2"]), PropTypes.string]),
+  /**
+   * The component maps the variant prop to a range of different HTML element types.
+   * For instance, subtitle1 to `<h6>`.
+   * If you wish to change that mapping, you can provide your own.
+   * Alternatively, you can use the `component` prop.
+   * @default {
+   *   h1: 'h1',
+   *   h2: 'h2',
+   *   h3: 'h3',
+   *   h4: 'h4',
+   *   h5: 'h5',
+   *   h6: 'h6',
+   *   subtitle1: 'h6',
+   *   subtitle2: 'h6',
+   *   body1: 'p',
+   *   body2: 'p',
+   *   inherit: 'p',
+   * }
+   */
+  variantMapping: PropTypes.object
+};
 const visuallyHidden = {
   border: 0,
   clip: "rect(0 0 0 0)",
@@ -29086,10 +29411,10 @@ const useUtilityClasses$2 = (ownerState) => {
     track,
     classes,
     color: color2,
-    size
+    size: size2
   } = ownerState;
   const slots = {
-    root: ["root", disabled && "disabled", dragging && "dragging", marked && "marked", orientation === "vertical" && "vertical", track === "inverted" && "trackInverted", track === false && "trackFalse", color2 && `color${capitalize(color2)}`, size && `size${capitalize(size)}`],
+    root: ["root", disabled && "disabled", dragging && "dragging", marked && "marked", orientation === "vertical" && "vertical", track === "inverted" && "trackInverted", track === false && "trackFalse", color2 && `color${capitalize(color2)}`, size2 && `size${capitalize(size2)}`],
     rail: ["rail"],
     track: ["track"],
     mark: ["mark"],
@@ -29097,7 +29422,7 @@ const useUtilityClasses$2 = (ownerState) => {
     markLabel: ["markLabel"],
     markLabelActive: ["markLabelActive"],
     valueLabel: ["valueLabel"],
-    thumb: ["thumb", disabled && "disabled", size && `thumbSize${capitalize(size)}`, color2 && `thumbColor${capitalize(color2)}`],
+    thumb: ["thumb", disabled && "disabled", size2 && `thumbSize${capitalize(size2)}`, color2 && `thumbColor${capitalize(color2)}`],
     active: ["active"],
     disabled: ["disabled"],
     focusVisible: ["focusVisible"]
@@ -29136,7 +29461,7 @@ const Slider = /* @__PURE__ */ React.forwardRef(function Slider2(inputProps, ref
     onChangeCommitted,
     orientation = "horizontal",
     shiftStep = 10,
-    size = "medium",
+    size: size2 = "medium",
     step = 1,
     scale: scale2 = Identity,
     slotProps,
@@ -29159,7 +29484,7 @@ const Slider = /* @__PURE__ */ React.forwardRef(function Slider2(inputProps, ref
     orientation,
     marks: marksProp,
     color: color2,
-    size,
+    size: size2,
     step,
     shiftStep,
     scale: scale2,
@@ -29658,11 +29983,11 @@ const useUtilityClasses$1 = (ownerState) => {
     variant,
     align,
     padding: padding2,
-    size,
+    size: size2,
     stickyHeader
   } = ownerState;
   const slots = {
-    root: ["root", variant, stickyHeader && "stickyHeader", align !== "inherit" && `align${capitalize(align)}`, padding2 !== "normal" && `padding${capitalize(padding2)}`, `size${capitalize(size)}`]
+    root: ["root", variant, stickyHeader && "stickyHeader", align !== "inherit" && `align${capitalize(align)}`, padding2 !== "normal" && `padding${capitalize(padding2)}`, `size${capitalize(size2)}`]
   };
   return composeClasses(slots, getTableCellUtilityClass, classes);
 };
@@ -30956,13 +31281,13 @@ function toValue(str, measurement, popperOffsets, referenceOffsets) {
     var rect = getClientRect(element);
     return rect[measurement] / 100 * value;
   } else if (unit2 === "vh" || unit2 === "vw") {
-    var size = void 0;
+    var size2 = void 0;
     if (unit2 === "vh") {
-      size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
+      size2 = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
     } else {
-      size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
+      size2 = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
     }
-    return size / 100 * value;
+    return size2 / 100 * value;
   } else {
     return value;
   }
@@ -31736,6 +32061,668 @@ const Popper = React.forwardRef((props, ref) => {
     ...style2
   }, children: typeof children2 === "function" ? children2(childProps) : children2 }) });
 });
+var safeIsNaN = Number.isNaN || function ponyfill(value) {
+  return typeof value === "number" && value !== value;
+};
+function isEqual$1(first, second) {
+  if (first === second) {
+    return true;
+  }
+  if (safeIsNaN(first) && safeIsNaN(second)) {
+    return true;
+  }
+  return false;
+}
+function areInputsEqual(newInputs, lastInputs) {
+  if (newInputs.length !== lastInputs.length) {
+    return false;
+  }
+  for (var i2 = 0; i2 < newInputs.length; i2++) {
+    if (!isEqual$1(newInputs[i2], lastInputs[i2])) {
+      return false;
+    }
+  }
+  return true;
+}
+function memoizeOne(resultFn, isEqual2) {
+  if (isEqual2 === void 0) {
+    isEqual2 = areInputsEqual;
+  }
+  var lastThis;
+  var lastArgs = [];
+  var lastResult;
+  var calledOnce = false;
+  function memoized() {
+    var newArgs = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      newArgs[_i] = arguments[_i];
+    }
+    if (calledOnce && lastThis === this && isEqual2(newArgs, lastArgs)) {
+      return lastResult;
+    }
+    lastResult = resultFn.apply(this, newArgs);
+    calledOnce = true;
+    lastThis = this;
+    lastArgs = newArgs;
+    return lastResult;
+  }
+  return memoized;
+}
+var hasNativePerformanceNow = typeof performance === "object" && typeof performance.now === "function";
+var now = hasNativePerformanceNow ? function() {
+  return performance.now();
+} : function() {
+  return Date.now();
+};
+function cancelTimeout(timeoutID) {
+  cancelAnimationFrame(timeoutID.id);
+}
+function requestTimeout(callback, delay) {
+  var start = now();
+  function tick() {
+    if (now() - start >= delay) {
+      callback.call(null);
+    } else {
+      timeoutID.id = requestAnimationFrame(tick);
+    }
+  }
+  var timeoutID = {
+    id: requestAnimationFrame(tick)
+  };
+  return timeoutID;
+}
+var size = -1;
+function getScrollbarSize(recalculate) {
+  if (recalculate === void 0) {
+    recalculate = false;
+  }
+  if (size === -1 || recalculate) {
+    var div = document.createElement("div");
+    var style2 = div.style;
+    style2.width = "50px";
+    style2.height = "50px";
+    style2.overflow = "scroll";
+    document.body.appendChild(div);
+    size = div.offsetWidth - div.clientWidth;
+    document.body.removeChild(div);
+  }
+  return size;
+}
+var cachedRTLResult = null;
+function getRTLOffsetType(recalculate) {
+  if (recalculate === void 0) {
+    recalculate = false;
+  }
+  if (cachedRTLResult === null || recalculate) {
+    var outerDiv = document.createElement("div");
+    var outerStyle = outerDiv.style;
+    outerStyle.width = "50px";
+    outerStyle.height = "50px";
+    outerStyle.overflow = "scroll";
+    outerStyle.direction = "rtl";
+    var innerDiv = document.createElement("div");
+    var innerStyle = innerDiv.style;
+    innerStyle.width = "100px";
+    innerStyle.height = "100px";
+    outerDiv.appendChild(innerDiv);
+    document.body.appendChild(outerDiv);
+    if (outerDiv.scrollLeft > 0) {
+      cachedRTLResult = "positive-descending";
+    } else {
+      outerDiv.scrollLeft = 1;
+      if (outerDiv.scrollLeft === 0) {
+        cachedRTLResult = "negative";
+      } else {
+        cachedRTLResult = "positive-ascending";
+      }
+    }
+    document.body.removeChild(outerDiv);
+    return cachedRTLResult;
+  }
+  return cachedRTLResult;
+}
+var IS_SCROLLING_DEBOUNCE_INTERVAL$1 = 150;
+var defaultItemKey$1 = function defaultItemKey3(index2, data) {
+  return index2;
+};
+var devWarningsDirection = null;
+var devWarningsTagName$1 = null;
+{
+  if (typeof window !== "undefined" && typeof window.WeakSet !== "undefined") {
+    devWarningsDirection = /* @__PURE__ */ new WeakSet();
+    devWarningsTagName$1 = /* @__PURE__ */ new WeakSet();
+  }
+}
+function createListComponent(_ref) {
+  var _class;
+  var getItemOffset3 = _ref.getItemOffset, getEstimatedTotalSize4 = _ref.getEstimatedTotalSize, getItemSize3 = _ref.getItemSize, getOffsetForIndexAndAlignment5 = _ref.getOffsetForIndexAndAlignment, getStartIndexForOffset3 = _ref.getStartIndexForOffset, getStopIndexForStartIndex3 = _ref.getStopIndexForStartIndex, initInstanceProps5 = _ref.initInstanceProps, shouldResetStyleCacheOnItemSizeChange = _ref.shouldResetStyleCacheOnItemSizeChange, validateProps5 = _ref.validateProps;
+  return _class = /* @__PURE__ */ function(_PureComponent) {
+    _inheritsLoose(List, _PureComponent);
+    function List(props) {
+      var _this;
+      _this = _PureComponent.call(this, props) || this;
+      _this._instanceProps = initInstanceProps5(_this.props, _assertThisInitialized(_this));
+      _this._outerRef = void 0;
+      _this._resetIsScrollingTimeoutId = null;
+      _this.state = {
+        instance: _assertThisInitialized(_this),
+        isScrolling: false,
+        scrollDirection: "forward",
+        scrollOffset: typeof _this.props.initialScrollOffset === "number" ? _this.props.initialScrollOffset : 0,
+        scrollUpdateWasRequested: false
+      };
+      _this._callOnItemsRendered = void 0;
+      _this._callOnItemsRendered = memoizeOne(function(overscanStartIndex, overscanStopIndex, visibleStartIndex, visibleStopIndex) {
+        return _this.props.onItemsRendered({
+          overscanStartIndex,
+          overscanStopIndex,
+          visibleStartIndex,
+          visibleStopIndex
+        });
+      });
+      _this._callOnScroll = void 0;
+      _this._callOnScroll = memoizeOne(function(scrollDirection, scrollOffset, scrollUpdateWasRequested) {
+        return _this.props.onScroll({
+          scrollDirection,
+          scrollOffset,
+          scrollUpdateWasRequested
+        });
+      });
+      _this._getItemStyle = void 0;
+      _this._getItemStyle = function(index2) {
+        var _this$props = _this.props, direction = _this$props.direction, itemSize = _this$props.itemSize, layout = _this$props.layout;
+        var itemStyleCache = _this._getItemStyleCache(shouldResetStyleCacheOnItemSizeChange && itemSize, shouldResetStyleCacheOnItemSizeChange && layout, shouldResetStyleCacheOnItemSizeChange && direction);
+        var style2;
+        if (itemStyleCache.hasOwnProperty(index2)) {
+          style2 = itemStyleCache[index2];
+        } else {
+          var _offset = getItemOffset3(_this.props, index2, _this._instanceProps);
+          var size2 = getItemSize3(_this.props, index2, _this._instanceProps);
+          var isHorizontal = direction === "horizontal" || layout === "horizontal";
+          var isRtl = direction === "rtl";
+          var offsetHorizontal = isHorizontal ? _offset : 0;
+          itemStyleCache[index2] = style2 = {
+            position: "absolute",
+            left: isRtl ? void 0 : offsetHorizontal,
+            right: isRtl ? offsetHorizontal : void 0,
+            top: !isHorizontal ? _offset : 0,
+            height: !isHorizontal ? size2 : "100%",
+            width: isHorizontal ? size2 : "100%"
+          };
+        }
+        return style2;
+      };
+      _this._getItemStyleCache = void 0;
+      _this._getItemStyleCache = memoizeOne(function(_, __, ___) {
+        return {};
+      });
+      _this._onScrollHorizontal = function(event) {
+        var _event$currentTarget = event.currentTarget, clientWidth = _event$currentTarget.clientWidth, scrollLeft = _event$currentTarget.scrollLeft, scrollWidth = _event$currentTarget.scrollWidth;
+        _this.setState(function(prevState) {
+          if (prevState.scrollOffset === scrollLeft) {
+            return null;
+          }
+          var direction = _this.props.direction;
+          var scrollOffset = scrollLeft;
+          if (direction === "rtl") {
+            switch (getRTLOffsetType()) {
+              case "negative":
+                scrollOffset = -scrollLeft;
+                break;
+              case "positive-descending":
+                scrollOffset = scrollWidth - clientWidth - scrollLeft;
+                break;
+            }
+          }
+          scrollOffset = Math.max(0, Math.min(scrollOffset, scrollWidth - clientWidth));
+          return {
+            isScrolling: true,
+            scrollDirection: prevState.scrollOffset < scrollOffset ? "forward" : "backward",
+            scrollOffset,
+            scrollUpdateWasRequested: false
+          };
+        }, _this._resetIsScrollingDebounced);
+      };
+      _this._onScrollVertical = function(event) {
+        var _event$currentTarget2 = event.currentTarget, clientHeight = _event$currentTarget2.clientHeight, scrollHeight = _event$currentTarget2.scrollHeight, scrollTop = _event$currentTarget2.scrollTop;
+        _this.setState(function(prevState) {
+          if (prevState.scrollOffset === scrollTop) {
+            return null;
+          }
+          var scrollOffset = Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight));
+          return {
+            isScrolling: true,
+            scrollDirection: prevState.scrollOffset < scrollOffset ? "forward" : "backward",
+            scrollOffset,
+            scrollUpdateWasRequested: false
+          };
+        }, _this._resetIsScrollingDebounced);
+      };
+      _this._outerRefSetter = function(ref) {
+        var outerRef = _this.props.outerRef;
+        _this._outerRef = ref;
+        if (typeof outerRef === "function") {
+          outerRef(ref);
+        } else if (outerRef != null && typeof outerRef === "object" && outerRef.hasOwnProperty("current")) {
+          outerRef.current = ref;
+        }
+      };
+      _this._resetIsScrollingDebounced = function() {
+        if (_this._resetIsScrollingTimeoutId !== null) {
+          cancelTimeout(_this._resetIsScrollingTimeoutId);
+        }
+        _this._resetIsScrollingTimeoutId = requestTimeout(_this._resetIsScrolling, IS_SCROLLING_DEBOUNCE_INTERVAL$1);
+      };
+      _this._resetIsScrolling = function() {
+        _this._resetIsScrollingTimeoutId = null;
+        _this.setState({
+          isScrolling: false
+        }, function() {
+          _this._getItemStyleCache(-1, null);
+        });
+      };
+      return _this;
+    }
+    List.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {
+      validateSharedProps$1(nextProps, prevState);
+      validateProps5(nextProps);
+      return null;
+    };
+    var _proto = List.prototype;
+    _proto.scrollTo = function scrollTo(scrollOffset) {
+      scrollOffset = Math.max(0, scrollOffset);
+      this.setState(function(prevState) {
+        if (prevState.scrollOffset === scrollOffset) {
+          return null;
+        }
+        return {
+          scrollDirection: prevState.scrollOffset < scrollOffset ? "forward" : "backward",
+          scrollOffset,
+          scrollUpdateWasRequested: true
+        };
+      }, this._resetIsScrollingDebounced);
+    };
+    _proto.scrollToItem = function scrollToItem(index2, align) {
+      if (align === void 0) {
+        align = "auto";
+      }
+      var _this$props2 = this.props, itemCount = _this$props2.itemCount, layout = _this$props2.layout;
+      var scrollOffset = this.state.scrollOffset;
+      index2 = Math.max(0, Math.min(index2, itemCount - 1));
+      var scrollbarSize = 0;
+      if (this._outerRef) {
+        var outerRef = this._outerRef;
+        if (layout === "vertical") {
+          scrollbarSize = outerRef.scrollWidth > outerRef.clientWidth ? getScrollbarSize() : 0;
+        } else {
+          scrollbarSize = outerRef.scrollHeight > outerRef.clientHeight ? getScrollbarSize() : 0;
+        }
+      }
+      this.scrollTo(getOffsetForIndexAndAlignment5(this.props, index2, align, scrollOffset, this._instanceProps, scrollbarSize));
+    };
+    _proto.componentDidMount = function componentDidMount() {
+      var _this$props3 = this.props, direction = _this$props3.direction, initialScrollOffset = _this$props3.initialScrollOffset, layout = _this$props3.layout;
+      if (typeof initialScrollOffset === "number" && this._outerRef != null) {
+        var outerRef = this._outerRef;
+        if (direction === "horizontal" || layout === "horizontal") {
+          outerRef.scrollLeft = initialScrollOffset;
+        } else {
+          outerRef.scrollTop = initialScrollOffset;
+        }
+      }
+      this._callPropsCallbacks();
+    };
+    _proto.componentDidUpdate = function componentDidUpdate() {
+      var _this$props4 = this.props, direction = _this$props4.direction, layout = _this$props4.layout;
+      var _this$state = this.state, scrollOffset = _this$state.scrollOffset, scrollUpdateWasRequested = _this$state.scrollUpdateWasRequested;
+      if (scrollUpdateWasRequested && this._outerRef != null) {
+        var outerRef = this._outerRef;
+        if (direction === "horizontal" || layout === "horizontal") {
+          if (direction === "rtl") {
+            switch (getRTLOffsetType()) {
+              case "negative":
+                outerRef.scrollLeft = -scrollOffset;
+                break;
+              case "positive-ascending":
+                outerRef.scrollLeft = scrollOffset;
+                break;
+              default:
+                var clientWidth = outerRef.clientWidth, scrollWidth = outerRef.scrollWidth;
+                outerRef.scrollLeft = scrollWidth - clientWidth - scrollOffset;
+                break;
+            }
+          } else {
+            outerRef.scrollLeft = scrollOffset;
+          }
+        } else {
+          outerRef.scrollTop = scrollOffset;
+        }
+      }
+      this._callPropsCallbacks();
+    };
+    _proto.componentWillUnmount = function componentWillUnmount() {
+      if (this._resetIsScrollingTimeoutId !== null) {
+        cancelTimeout(this._resetIsScrollingTimeoutId);
+      }
+    };
+    _proto.render = function render() {
+      var _this$props5 = this.props, children2 = _this$props5.children, className = _this$props5.className, direction = _this$props5.direction, height2 = _this$props5.height, innerRef = _this$props5.innerRef, innerElementType = _this$props5.innerElementType, innerTagName = _this$props5.innerTagName, itemCount = _this$props5.itemCount, itemData = _this$props5.itemData, _this$props5$itemKey = _this$props5.itemKey, itemKey = _this$props5$itemKey === void 0 ? defaultItemKey$1 : _this$props5$itemKey, layout = _this$props5.layout, outerElementType = _this$props5.outerElementType, outerTagName = _this$props5.outerTagName, style2 = _this$props5.style, useIsScrolling = _this$props5.useIsScrolling, width2 = _this$props5.width;
+      var isScrolling = this.state.isScrolling;
+      var isHorizontal = direction === "horizontal" || layout === "horizontal";
+      var onScroll = isHorizontal ? this._onScrollHorizontal : this._onScrollVertical;
+      var _this$_getRangeToRend = this._getRangeToRender(), startIndex = _this$_getRangeToRend[0], stopIndex = _this$_getRangeToRend[1];
+      var items = [];
+      if (itemCount > 0) {
+        for (var _index = startIndex; _index <= stopIndex; _index++) {
+          items.push(createElement(children2, {
+            data: itemData,
+            key: itemKey(_index, itemData),
+            index: _index,
+            isScrolling: useIsScrolling ? isScrolling : void 0,
+            style: this._getItemStyle(_index)
+          }));
+        }
+      }
+      var estimatedTotalSize = getEstimatedTotalSize4(this.props, this._instanceProps);
+      return createElement(outerElementType || outerTagName || "div", {
+        className,
+        onScroll,
+        ref: this._outerRefSetter,
+        style: _extends$1({
+          position: "relative",
+          height: height2,
+          width: width2,
+          overflow: "auto",
+          WebkitOverflowScrolling: "touch",
+          willChange: "transform",
+          direction
+        }, style2)
+      }, createElement(innerElementType || innerTagName || "div", {
+        children: items,
+        ref: innerRef,
+        style: {
+          height: isHorizontal ? "100%" : estimatedTotalSize,
+          pointerEvents: isScrolling ? "none" : void 0,
+          width: isHorizontal ? estimatedTotalSize : "100%"
+        }
+      }));
+    };
+    _proto._callPropsCallbacks = function _callPropsCallbacks() {
+      if (typeof this.props.onItemsRendered === "function") {
+        var itemCount = this.props.itemCount;
+        if (itemCount > 0) {
+          var _this$_getRangeToRend2 = this._getRangeToRender(), _overscanStartIndex = _this$_getRangeToRend2[0], _overscanStopIndex = _this$_getRangeToRend2[1], _visibleStartIndex = _this$_getRangeToRend2[2], _visibleStopIndex = _this$_getRangeToRend2[3];
+          this._callOnItemsRendered(_overscanStartIndex, _overscanStopIndex, _visibleStartIndex, _visibleStopIndex);
+        }
+      }
+      if (typeof this.props.onScroll === "function") {
+        var _this$state2 = this.state, _scrollDirection = _this$state2.scrollDirection, _scrollOffset = _this$state2.scrollOffset, _scrollUpdateWasRequested = _this$state2.scrollUpdateWasRequested;
+        this._callOnScroll(_scrollDirection, _scrollOffset, _scrollUpdateWasRequested);
+      }
+    };
+    _proto._getRangeToRender = function _getRangeToRender() {
+      var _this$props6 = this.props, itemCount = _this$props6.itemCount, overscanCount = _this$props6.overscanCount;
+      var _this$state3 = this.state, isScrolling = _this$state3.isScrolling, scrollDirection = _this$state3.scrollDirection, scrollOffset = _this$state3.scrollOffset;
+      if (itemCount === 0) {
+        return [0, 0, 0, 0];
+      }
+      var startIndex = getStartIndexForOffset3(this.props, scrollOffset, this._instanceProps);
+      var stopIndex = getStopIndexForStartIndex3(this.props, startIndex, scrollOffset, this._instanceProps);
+      var overscanBackward = !isScrolling || scrollDirection === "backward" ? Math.max(1, overscanCount) : 1;
+      var overscanForward = !isScrolling || scrollDirection === "forward" ? Math.max(1, overscanCount) : 1;
+      return [Math.max(0, startIndex - overscanBackward), Math.max(0, Math.min(itemCount - 1, stopIndex + overscanForward)), startIndex, stopIndex];
+    };
+    return List;
+  }(PureComponent), _class.defaultProps = {
+    direction: "ltr",
+    itemData: void 0,
+    layout: "vertical",
+    overscanCount: 2,
+    useIsScrolling: false
+  }, _class;
+}
+var validateSharedProps$1 = function validateSharedProps3(_ref2, _ref3) {
+  var children2 = _ref2.children, direction = _ref2.direction, height2 = _ref2.height, layout = _ref2.layout, innerTagName = _ref2.innerTagName, outerTagName = _ref2.outerTagName, width2 = _ref2.width;
+  var instance = _ref3.instance;
+  {
+    if (innerTagName != null || outerTagName != null) {
+      if (devWarningsTagName$1 && !devWarningsTagName$1.has(instance)) {
+        devWarningsTagName$1.add(instance);
+        console.warn("The innerTagName and outerTagName props have been deprecated. Please use the innerElementType and outerElementType props instead.");
+      }
+    }
+    var isHorizontal = direction === "horizontal" || layout === "horizontal";
+    switch (direction) {
+      case "horizontal":
+      case "vertical":
+        if (devWarningsDirection && !devWarningsDirection.has(instance)) {
+          devWarningsDirection.add(instance);
+          console.warn('The direction prop should be either "ltr" (default) or "rtl". Please use the layout prop to specify "vertical" (default) or "horizontal" orientation.');
+        }
+        break;
+      case "ltr":
+      case "rtl":
+        break;
+      default:
+        throw Error('An invalid "direction" prop has been specified. Value should be either "ltr" or "rtl". ' + ('"' + direction + '" was specified.'));
+    }
+    switch (layout) {
+      case "horizontal":
+      case "vertical":
+        break;
+      default:
+        throw Error('An invalid "layout" prop has been specified. Value should be either "horizontal" or "vertical". ' + ('"' + layout + '" was specified.'));
+    }
+    if (children2 == null) {
+      throw Error('An invalid "children" prop has been specified. Value should be a React component. ' + ('"' + (children2 === null ? "null" : typeof children2) + '" was specified.'));
+    }
+    if (isHorizontal && typeof width2 !== "number") {
+      throw Error('An invalid "width" prop has been specified. Horizontal lists must specify a number for width. ' + ('"' + (width2 === null ? "null" : typeof width2) + '" was specified.'));
+    } else if (!isHorizontal && typeof height2 !== "number") {
+      throw Error('An invalid "height" prop has been specified. Vertical lists must specify a number for height. ' + ('"' + (height2 === null ? "null" : typeof height2) + '" was specified.'));
+    }
+  }
+};
+var DEFAULT_ESTIMATED_ITEM_SIZE$1 = 50;
+var getItemMetadata$1 = function getItemMetadata3(props, index2, instanceProps) {
+  var _ref = props, itemSize = _ref.itemSize;
+  var itemMetadataMap = instanceProps.itemMetadataMap, lastMeasuredIndex = instanceProps.lastMeasuredIndex;
+  if (index2 > lastMeasuredIndex) {
+    var offset2 = 0;
+    if (lastMeasuredIndex >= 0) {
+      var itemMetadata = itemMetadataMap[lastMeasuredIndex];
+      offset2 = itemMetadata.offset + itemMetadata.size;
+    }
+    for (var i2 = lastMeasuredIndex + 1; i2 <= index2; i2++) {
+      var size2 = itemSize(i2);
+      itemMetadataMap[i2] = {
+        offset: offset2,
+        size: size2
+      };
+      offset2 += size2;
+    }
+    instanceProps.lastMeasuredIndex = index2;
+  }
+  return itemMetadataMap[index2];
+};
+var findNearestItem$1 = function findNearestItem3(props, instanceProps, offset2) {
+  var itemMetadataMap = instanceProps.itemMetadataMap, lastMeasuredIndex = instanceProps.lastMeasuredIndex;
+  var lastMeasuredItemOffset = lastMeasuredIndex > 0 ? itemMetadataMap[lastMeasuredIndex].offset : 0;
+  if (lastMeasuredItemOffset >= offset2) {
+    return findNearestItemBinarySearch$1(props, instanceProps, lastMeasuredIndex, 0, offset2);
+  } else {
+    return findNearestItemExponentialSearch$1(props, instanceProps, Math.max(0, lastMeasuredIndex), offset2);
+  }
+};
+var findNearestItemBinarySearch$1 = function findNearestItemBinarySearch3(props, instanceProps, high, low, offset2) {
+  while (low <= high) {
+    var middle = low + Math.floor((high - low) / 2);
+    var currentOffset = getItemMetadata$1(props, middle, instanceProps).offset;
+    if (currentOffset === offset2) {
+      return middle;
+    } else if (currentOffset < offset2) {
+      low = middle + 1;
+    } else if (currentOffset > offset2) {
+      high = middle - 1;
+    }
+  }
+  if (low > 0) {
+    return low - 1;
+  } else {
+    return 0;
+  }
+};
+var findNearestItemExponentialSearch$1 = function findNearestItemExponentialSearch3(props, instanceProps, index2, offset2) {
+  var itemCount = props.itemCount;
+  var interval = 1;
+  while (index2 < itemCount && getItemMetadata$1(props, index2, instanceProps).offset < offset2) {
+    index2 += interval;
+    interval *= 2;
+  }
+  return findNearestItemBinarySearch$1(props, instanceProps, Math.min(index2, itemCount - 1), Math.floor(index2 / 2), offset2);
+};
+var getEstimatedTotalSize = function getEstimatedTotalSize2(_ref2, _ref3) {
+  var itemCount = _ref2.itemCount;
+  var itemMetadataMap = _ref3.itemMetadataMap, estimatedItemSize = _ref3.estimatedItemSize, lastMeasuredIndex = _ref3.lastMeasuredIndex;
+  var totalSizeOfMeasuredItems = 0;
+  if (lastMeasuredIndex >= itemCount) {
+    lastMeasuredIndex = itemCount - 1;
+  }
+  if (lastMeasuredIndex >= 0) {
+    var itemMetadata = itemMetadataMap[lastMeasuredIndex];
+    totalSizeOfMeasuredItems = itemMetadata.offset + itemMetadata.size;
+  }
+  var numUnmeasuredItems = itemCount - lastMeasuredIndex - 1;
+  var totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedItemSize;
+  return totalSizeOfMeasuredItems + totalSizeOfUnmeasuredItems;
+};
+var VariableSizeList$1 = /* @__PURE__ */ createListComponent({
+  getItemOffset: function getItemOffset(props, index2, instanceProps) {
+    return getItemMetadata$1(props, index2, instanceProps).offset;
+  },
+  getItemSize: function getItemSize(props, index2, instanceProps) {
+    return instanceProps.itemMetadataMap[index2].size;
+  },
+  getEstimatedTotalSize,
+  getOffsetForIndexAndAlignment: function getOffsetForIndexAndAlignment3(props, index2, align, scrollOffset, instanceProps, scrollbarSize) {
+    var direction = props.direction, height2 = props.height, layout = props.layout, width2 = props.width;
+    var isHorizontal = direction === "horizontal" || layout === "horizontal";
+    var size2 = isHorizontal ? width2 : height2;
+    var itemMetadata = getItemMetadata$1(props, index2, instanceProps);
+    var estimatedTotalSize = getEstimatedTotalSize(props, instanceProps);
+    var maxOffset = Math.max(0, Math.min(estimatedTotalSize - size2, itemMetadata.offset));
+    var minOffset = Math.max(0, itemMetadata.offset - size2 + itemMetadata.size + scrollbarSize);
+    if (align === "smart") {
+      if (scrollOffset >= minOffset - size2 && scrollOffset <= maxOffset + size2) {
+        align = "auto";
+      } else {
+        align = "center";
+      }
+    }
+    switch (align) {
+      case "start":
+        return maxOffset;
+      case "end":
+        return minOffset;
+      case "center":
+        return Math.round(minOffset + (maxOffset - minOffset) / 2);
+      case "auto":
+      default:
+        if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
+          return scrollOffset;
+        } else if (scrollOffset < minOffset) {
+          return minOffset;
+        } else {
+          return maxOffset;
+        }
+    }
+  },
+  getStartIndexForOffset: function getStartIndexForOffset(props, offset2, instanceProps) {
+    return findNearestItem$1(props, instanceProps, offset2);
+  },
+  getStopIndexForStartIndex: function getStopIndexForStartIndex(props, startIndex, scrollOffset, instanceProps) {
+    var direction = props.direction, height2 = props.height, itemCount = props.itemCount, layout = props.layout, width2 = props.width;
+    var isHorizontal = direction === "horizontal" || layout === "horizontal";
+    var size2 = isHorizontal ? width2 : height2;
+    var itemMetadata = getItemMetadata$1(props, startIndex, instanceProps);
+    var maxOffset = scrollOffset + size2;
+    var offset2 = itemMetadata.offset + itemMetadata.size;
+    var stopIndex = startIndex;
+    while (stopIndex < itemCount - 1 && offset2 < maxOffset) {
+      stopIndex++;
+      offset2 += getItemMetadata$1(props, stopIndex, instanceProps).size;
+    }
+    return stopIndex;
+  },
+  initInstanceProps: function initInstanceProps2(props, instance) {
+    var _ref4 = props, estimatedItemSize = _ref4.estimatedItemSize;
+    var instanceProps = {
+      itemMetadataMap: {},
+      estimatedItemSize: estimatedItemSize || DEFAULT_ESTIMATED_ITEM_SIZE$1,
+      lastMeasuredIndex: -1
+    };
+    instance.resetAfterIndex = function(index2, shouldForceUpdate) {
+      if (shouldForceUpdate === void 0) {
+        shouldForceUpdate = true;
+      }
+      instanceProps.lastMeasuredIndex = Math.min(instanceProps.lastMeasuredIndex, index2 - 1);
+      instance._getItemStyleCache(-1);
+      if (shouldForceUpdate) {
+        instance.forceUpdate();
+      }
+    };
+    return instanceProps;
+  },
+  shouldResetStyleCacheOnItemSizeChange: false,
+  validateProps: function validateProps2(_ref5) {
+    var itemSize = _ref5.itemSize;
+    {
+      if (typeof itemSize !== "function") {
+        throw Error('An invalid "itemSize" prop has been specified. Value should be a function. ' + ('"' + (itemSize === null ? "null" : typeof itemSize) + '" was specified.'));
+      }
+    }
+  }
+});
+const VariableSizeList = VariableSizeList$1;
+const LIST_ROW_HEIGHT = 48;
+makeStyles()(() => ({
+  searchInput: {
+    lineHeight: "initial",
+    height: "auto !important"
+  }
+}));
+const OuterElementContext = React__default.createContext({});
+const OuterElementType = React__default.forwardRef((props, ref) => {
+  const outerProps = React__default.useContext(OuterElementContext);
+  return jsxRuntimeExports.jsx("div", { ref, ...props, ...outerProps });
+});
+function ListRow(props) {
+  const { data, index: index2, style: style2 } = props;
+  const dataSet = data[index2];
+  const inlineStyle = {
+    ...style2,
+    top: style2.top + 8
+  };
+  const [props0, option, getItemLabel] = dataSet;
+  const { key, ...optionProps } = props0;
+  return jsxRuntimeExports.jsx(Typography, { component: "li", ...optionProps, noWrap: true, style: inlineStyle, children: getItemLabel(option) }, key);
+}
+function useResetCache(itemCount) {
+  const ref = useRef(null);
+  useEffect(() => {
+    if (ref.current != null) {
+      ref.current.resetAfterIndex(0, true);
+    }
+  }, [itemCount]);
+  return ref;
+}
+React__default.forwardRef((props, ref) => {
+  const { children: children2, ...other } = props;
+  const items = children2;
+  const itemCount = items.length;
+  const gridRef = useResetCache(itemCount);
+  return jsxRuntimeExports.jsx("div", { ref, children: jsxRuntimeExports.jsx(OuterElementContext.Provider, { value: other, children: jsxRuntimeExports.jsx(VariableSizeList, { height: Math.min(8, itemCount) * LIST_ROW_HEIGHT, itemSize: () => LIST_ROW_HEIGHT, width: "100%", innerElementType: "ul", outerElementType: OuterElementType, overscanCount: 5, ref: gridRef, itemCount, itemData: items, children: ListRow }) }) });
+});
 var xhtml = "http://www.w3.org/1999/xhtml";
 const namespaces = {
   svg: "http://www.w3.org/2000/svg",
@@ -32041,9 +33028,9 @@ function selection_node() {
   return null;
 }
 function selection_size() {
-  let size = 0;
-  for (const node2 of this) ++size;
-  return size;
+  let size2 = 0;
+  for (const node2 of this) ++size2;
+  return size2;
 }
 function selection_empty() {
   return !this.node();
@@ -34023,7 +35010,7 @@ function Legend(props) {
         y += titleHeight;
         setPaths.forEach((setPath) => {
           var _a3;
-          const setColor2 = ((_a3 = obsSetColor == null ? void 0 : obsSetColor.find((d) => isEqual$1(d.path, setPath))) == null ? void 0 : _a3.color) || getDefaultColor(theme ?? "light");
+          const setColor2 = ((_a3 = obsSetColor == null ? void 0 : obsSetColor.find((d) => isEqual$2(d.path, setPath))) == null ? void 0 : _a3.color) || getDefaultColor(theme ?? "light");
           g2.append("rect").attr("x", 0).attr("y", y).attr("width", rectHeight).attr("height", rectHeight).attr("fill", `rgb(${setColor2[0]},${setColor2[1]},${setColor2[2]})`);
           g2.append("text").attr("text-anchor", "start").attr("dominant-baseline", "hanging").attr("x", rectHeight + rectMarginX).attr("y", y).text(setPath.at(-1) ?? "").style("font-size", "9px").style("fill", foregroundColor);
           y += rectHeight + rectMarginY;
@@ -37261,12 +38248,12 @@ const OESVertexArrayObject = function OESVertexArrayObject2(gl) {
         return original.getVertexAttrib.apply(this, arguments);
     }
   };
-  gl.vertexAttribPointer = function vertexAttribPointer(indx, size, type, normalized, stride, offset2) {
+  gl.vertexAttribPointer = function vertexAttribPointer(indx, size2, type, normalized, stride, offset2) {
     const vao = self2.currentVertexArrayObject;
     vao.maxAttrib = Math.max(vao.maxAttrib, indx);
     const attrib = vao.attribs[indx];
     attrib.buffer = self2.currentArrayBuffer;
-    attrib.size = size;
+    attrib.size = size2;
     attrib.type = type;
     attrib.normalized = normalized;
     attrib.stride = stride;
@@ -39158,7 +40145,7 @@ let Buffer$1 = class Buffer2 extends Resource$1 {
       sourceBuffer,
       readOffset = 0,
       writeOffset = 0,
-      size
+      size: size2
     } = _ref;
     const {
       gl
@@ -39166,7 +40153,7 @@ let Buffer$1 = class Buffer2 extends Resource$1 {
     assertWebGL2Context(gl);
     gl.bindBuffer(36662, sourceBuffer.handle);
     gl.bindBuffer(36663, this.handle);
-    gl.copyBufferSubData(36662, 36663, readOffset, writeOffset, size);
+    gl.copyBufferSubData(36662, 36663, readOffset, writeOffset, size2);
     gl.bindBuffer(36662, null);
     gl.bindBuffer(36663, null);
     this.debugData = null;
@@ -39208,11 +40195,11 @@ let Buffer$1 = class Buffer2 extends Resource$1 {
       target = this.target,
       index: index2 = this.accessor && this.accessor.index,
       offset: offset2 = 0,
-      size
+      size: size2
     } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
     if (target === 35345 || target === 35982) {
-      if (size !== void 0) {
-        this.gl.bindBufferRange(target, index2, this.handle, offset2, size);
+      if (size2 !== void 0) {
+        this.gl.bindBufferRange(target, index2, this.handle, offset2, size2);
       } else {
         assert$8(offset2 === 0);
         this.gl.bindBufferBase(target, index2, this.handle);
@@ -39892,47 +40879,47 @@ class Texture extends Resource$1 {
     };
   }
   _deduceImageSize(data, width2, height2) {
-    let size;
+    let size2;
     if (typeof ImageData !== "undefined" && data instanceof ImageData) {
-      size = {
+      size2 = {
         width: data.width,
         height: data.height
       };
     } else if (typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement) {
-      size = {
+      size2 = {
         width: data.naturalWidth,
         height: data.naturalHeight
       };
     } else if (typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement) {
-      size = {
+      size2 = {
         width: data.width,
         height: data.height
       };
     } else if (typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap) {
-      size = {
+      size2 = {
         width: data.width,
         height: data.height
       };
     } else if (typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement) {
-      size = {
+      size2 = {
         width: data.videoWidth,
         height: data.videoHeight
       };
     } else if (!data) {
-      size = {
+      size2 = {
         width: width2 >= 0 ? width2 : 1,
         height: height2 >= 0 ? height2 : 1
       };
     } else {
-      size = {
+      size2 = {
         width: width2,
         height: height2
       };
     }
-    assert$8(size, "Could not deduced texture size");
-    assert$8(width2 === void 0 || size.width === width2, "Deduced texture width does not match supplied width");
-    assert$8(height2 === void 0 || size.height === height2, "Deduced texture height does not match supplied height");
-    return size;
+    assert$8(size2, "Could not deduced texture size");
+    assert$8(width2 === void 0 || size2.width === width2, "Deduced texture width does not match supplied width");
+    assert$8(height2 === void 0 || size2.height === height2, "Deduced texture height does not match supplied height");
+    return size2;
   }
   _createHandle() {
     return this.gl.createTexture();
@@ -41891,11 +42878,11 @@ function getSamplerSetter() {
     return update2;
   };
 }
-function getArraySetter(functionName, toArray, size, uniformSetter) {
+function getArraySetter(functionName, toArray, size2, uniformSetter) {
   let cache2 = null;
   let cacheLength = null;
   return (gl, location, value) => {
-    const arrayValue = toArray(value, size);
+    const arrayValue = toArray(value, size2);
     const length2 = arrayValue.length;
     let update2 = false;
     if (cache2 === null) {
@@ -42090,11 +43077,11 @@ class ProgramConfiguration {
       const {
         name: name2,
         type,
-        size
+        size: size2
       } = gl.getActiveAttrib(program.handle, index2);
       const location = gl.getAttribLocation(program.handle, name2);
       if (location >= 0) {
-        this._addAttribute(location, name2, type, size);
+        this._addAttribute(location, name2, type, size2);
       }
     }
     this.attributeInfos.sort((a2, b) => a2.location - b.location);
@@ -42111,20 +43098,20 @@ class ProgramConfiguration {
       const {
         name: name2,
         type,
-        size
+        size: size2
       } = gl.getTransformFeedbackVarying(program.handle, location);
-      this._addVarying(location, name2, type, size);
+      this._addVarying(location, name2, type, size2);
     }
     this.varyingInfos.sort((a2, b) => a2.location - b.location);
   }
-  _addAttribute(location, name2, compositeType, size) {
+  _addAttribute(location, name2, compositeType, size2) {
     const {
       type,
       components
     } = decomposeCompositeGLType(compositeType);
     const accessor = {
       type,
-      size: size * components
+      size: size2 * components
     };
     this._inferProperties(location, name2, accessor);
     const attributeInfo = {
@@ -42141,14 +43128,14 @@ class ProgramConfiguration {
       accessor.divisor = 1;
     }
   }
-  _addVarying(location, name2, compositeType, size) {
+  _addVarying(location, name2, compositeType, size2) {
     const {
       type,
       components
     } = decomposeCompositeGLType(compositeType);
     const accessor = new Accessor({
       type,
-      size: size * components
+      size: size2 * components
     });
     const varying = {
       location,
@@ -42824,7 +43811,7 @@ class VertexArrayObject extends Resource$1 {
       return this.setElementBuffer(buffer, accessor);
     }
     const {
-      size,
+      size: size2,
       type,
       stride,
       offset: offset2,
@@ -42841,9 +43828,9 @@ class VertexArrayObject extends Resource$1 {
       gl.bindBuffer(34962, buffer.handle);
       if (integer) {
         assert$8(isWebGL2$1(gl));
-        gl2.vertexAttribIPointer(location, size, type, stride, offset2);
+        gl2.vertexAttribIPointer(location, size2, type, stride, offset2);
       } else {
-        gl.vertexAttribPointer(location, size, type, normalized, stride, offset2);
+        gl.vertexAttribPointer(location, size2, type, normalized, stride, offset2);
       }
       gl.enableVertexAttribArray(location);
       gl2.vertexAttribDivisor(location, divisor || 0);
@@ -43171,10 +44158,10 @@ class VertexArray {
     const currentAccessor = this.accessors[location] || {};
     const accessor = Accessor.resolve(accessInfo.accessor, currentAccessor, valueAccessor, appAccessor);
     const {
-      size,
+      size: size2,
       type
     } = accessor;
-    assert$8(Number.isFinite(size) && Number.isFinite(type));
+    assert$8(Number.isFinite(size2) && Number.isFinite(type));
     return {
       location,
       accessor
@@ -43306,12 +44293,12 @@ class VertexArray {
 function formatArrayValue(v, opts) {
   const {
     maxElts = 16,
-    size = 1
+    size: size2 = 1
   } = opts;
   let string2 = "[";
   for (let i2 = 0; i2 < v.length && i2 < maxElts; ++i2) {
     if (i2 > 0) {
-      string2 += ",".concat(i2 % size === 0 ? " " : "");
+      string2 += ",".concat(i2 % size2 === 0 ? " " : "");
     }
     string2 += formatValue$1(v[i2], opts);
   }
@@ -43476,7 +44463,7 @@ function getDebugTableRow(vertexArray, attribute, accessor, header) {
     };
   }
   let type = "NOT PROVIDED";
-  let size = 1;
+  let size2 = 1;
   let verts = 0;
   let bytes = 0;
   let isInteger;
@@ -43484,7 +44471,7 @@ function getDebugTableRow(vertexArray, attribute, accessor, header) {
   let value;
   if (accessor) {
     type = accessor.type;
-    size = accessor.size;
+    size2 = accessor.size;
     type = String(type).replace("Array", "");
     isInteger = type.indexOf("nt") !== -1;
   }
@@ -43497,41 +44484,41 @@ function getDebugTableRow(vertexArray, attribute, accessor, header) {
     marker2 = changed ? "*" : "";
     value = data;
     bytes = buffer.byteLength;
-    verts = bytes / data.BYTES_PER_ELEMENT / size;
+    verts = bytes / data.BYTES_PER_ELEMENT / size2;
     let format2;
     if (accessor) {
       const instanced = accessor.divisor > 0;
-      format2 = "".concat(instanced ? "I " : "P ", " ").concat(verts, " (x").concat(size, "=").concat(bytes, " bytes ").concat(getKey(gl, type), ")");
+      format2 = "".concat(instanced ? "I " : "P ", " ").concat(verts, " (x").concat(size2, "=").concat(bytes, " bytes ").concat(getKey(gl, type), ")");
     } else {
       isInteger = true;
       format2 = "".concat(bytes, " bytes");
     }
     return {
       [header]: "".concat(marker2).concat(formatValue$1(value, {
-        size,
+        size: size2,
         isInteger
       })),
       "Format ": format2
     };
   }
   value = attribute;
-  size = attribute.length;
+  size2 = attribute.length;
   type = String(attribute.constructor.name).replace("Array", "");
   isInteger = type.indexOf("nt") !== -1;
   return {
     [header]: "".concat(formatValue$1(value, {
-      size,
+      size: size2,
       isInteger
     }), " (constant)"),
-    "Format ": "".concat(size, "x").concat(type, " (constant)")
+    "Format ": "".concat(size2, "x").concat(type, " (constant)")
   };
 }
 function getGLSLDeclaration$1(name2, accessor) {
   const {
     type,
-    size
+    size: size2
   } = accessor;
-  const typeAndName = getCompositeGLType(type, size);
+  const typeAndName = getCompositeGLType(type, size2);
   return typeAndName ? "".concat(name2, " (").concat(typeAndName.name, ")") : name2;
 }
 function getDebugTableForProgramConfiguration(config2) {
@@ -43558,9 +44545,9 @@ function getDebugTableForProgramConfiguration(config2) {
 function getGLSLDeclaration(attributeInfo) {
   const {
     type,
-    size
+    size: size2
   } = attributeInfo.accessor;
-  const typeAndName = getCompositeGLType(type, size);
+  const typeAndName = getCompositeGLType(type, size2);
   if (typeAndName) {
     return "".concat(typeAndName.name, " ").concat(attributeInfo.name);
   }
@@ -50182,11 +51169,11 @@ class Geometry {
       const attribute = attributes[attributeName];
       const {
         value,
-        size,
+        size: size2,
         constant: constant2
       } = attribute;
-      if (!constant2 && value && size >= 1) {
-        vertexCount = Math.min(vertexCount, value.length / size);
+      if (!constant2 && value && size2 >= 1) {
+        vertexCount = Math.min(vertexCount, value.length / size2);
       }
     }
     assert$8(Number.isFinite(vertexCount));
@@ -50564,20 +51551,20 @@ function unpackIndexedGeometry(geometry2) {
     const {
       constant: constant2,
       value,
-      size
+      size: size2
     } = attribute;
-    if (constant2 || !size) {
+    if (constant2 || !size2) {
       continue;
     }
-    const unpackedValue = new value.constructor(vertexCount * size);
+    const unpackedValue = new value.constructor(vertexCount * size2);
     for (let x = 0; x < vertexCount; ++x) {
       const index2 = indices.value[x];
-      for (let i2 = 0; i2 < size; i2++) {
-        unpackedValue[x * size + i2] = value[index2 * size + i2];
+      for (let i2 = 0; i2 < size2; i2++) {
+        unpackedValue[x * size2 + i2] = value[index2 * size2 + i2];
       }
     }
     unpackedAttributes[attributeName] = {
-      size,
+      size: size2,
       value: unpackedValue
     };
   }
@@ -51498,11 +52485,11 @@ function fitBounds(options) {
   const padding2 = getPaddingObject(options.padding);
   const nw = lngLatToWorld([west, clamp$1(north, -85.051129, MAX_LATITUDE)]);
   const se = lngLatToWorld([east, clamp$1(south, -85.051129, MAX_LATITUDE)]);
-  const size = [Math.max(Math.abs(se[0] - nw[0]), minExtent), Math.max(Math.abs(se[1] - nw[1]), minExtent)];
+  const size2 = [Math.max(Math.abs(se[0] - nw[0]), minExtent), Math.max(Math.abs(se[1] - nw[1]), minExtent)];
   const targetSize = [width2 - padding2.left - padding2.right - Math.abs(offset2[0]) * 2, height2 - padding2.top - padding2.bottom - Math.abs(offset2[1]) * 2];
   assert$5(targetSize[0] > 0 && targetSize[1] > 0);
-  const scaleX2 = targetSize[0] / size[0];
-  const scaleY2 = targetSize[1] / size[1];
+  const scaleX2 = targetSize[0] / size2[0];
+  const scaleY2 = targetSize[1] / size2[1];
   const offsetX = (padding2.right - padding2.left) / 2 / scaleX2;
   const offsetY = (padding2.top - padding2.bottom) / 2 / scaleY2;
   const center2 = [(se[0] + nw[0]) / 2 + offsetX, (se[1] + nw[1]) / 2 + offsetY];
@@ -52621,7 +53608,7 @@ class TypedArrayManager {
     Object.assign(this.opts, options);
   }
   allocate(typedArray, count2, {
-    size = 1,
+    size: size2 = 1,
     type,
     padding: padding2 = 0,
     copy: copy2 = false,
@@ -52629,7 +53616,7 @@ class TypedArrayManager {
     maxCount
   }) {
     const Type2 = type || typedArray && typedArray.constructor || Float32Array;
-    const newSize = count2 * size + padding2;
+    const newSize = count2 * size2 + padding2;
     if (ArrayBuffer.isView(typedArray)) {
       if (newSize <= typedArray.length) {
         return typedArray;
@@ -52640,7 +53627,7 @@ class TypedArrayManager {
     }
     let maxSize = Infinity;
     if (maxCount) {
-      maxSize = maxCount * size + padding2;
+      maxSize = maxCount * size2 + padding2;
     }
     const newArray = this._allocate(Type2, newSize, initialize, maxSize);
     if (typedArray && copy2) {
@@ -52654,8 +53641,8 @@ class TypedArrayManager {
   release(typedArray) {
     this._release(typedArray);
   }
-  _allocate(Type2, size, initialize, maxSize) {
-    let sizeToAllocate = Math.max(Math.ceil(size * this.opts.overAlloc), 1);
+  _allocate(Type2, size2, initialize, maxSize) {
+    let sizeToAllocate = Math.max(Math.ceil(size2 * this.opts.overAlloc), 1);
     if (sizeToAllocate > maxSize) {
       sizeToAllocate = maxSize;
     }
@@ -52729,26 +53716,26 @@ function fp64LowPart(x) {
 let scratchArray;
 function toDoublePrecisionArray(typedArray, options) {
   const {
-    size = 1,
+    size: size2 = 1,
     startIndex = 0
   } = options;
   const endIndex = options.endIndex !== void 0 ? options.endIndex : typedArray.length;
-  const count2 = (endIndex - startIndex) / size;
+  const count2 = (endIndex - startIndex) / size2;
   scratchArray = defaultTypedArrayManager.allocate(scratchArray, count2, {
     type: Float32Array,
-    size: size * 2
+    size: size2 * 2
   });
   let sourceIndex = startIndex;
   let targetIndex = 0;
   while (sourceIndex < endIndex) {
-    for (let j = 0; j < size; j++) {
+    for (let j = 0; j < size2; j++) {
       const value = typedArray[sourceIndex++];
       scratchArray[targetIndex + j] = value;
-      scratchArray[targetIndex + j + size] = fp64LowPart(value);
+      scratchArray[targetIndex + j + size2] = fp64LowPart(value);
     }
-    targetIndex += size * 2;
+    targetIndex += size2 * 2;
   }
-  return scratchArray.subarray(0, count2 * size * 2);
+  return scratchArray.subarray(0, count2 * size2 * 2);
 }
 const DEGREES_TO_RADIANS$4 = Math.PI / 180;
 const IDENTITY = createMat4();
@@ -56407,15 +57394,15 @@ function getMaskViewport({
   });
 }
 function _doubleBounds(bounds2) {
-  const size = {
+  const size2 = {
     x: bounds2[2] - bounds2[0],
     y: bounds2[3] - bounds2[1]
   };
   const center2 = {
-    x: bounds2[0] + 0.5 * size.x,
-    y: bounds2[1] + 0.5 * size.y
+    x: bounds2[0] + 0.5 * size2.x,
+    y: bounds2[1] + 0.5 * size2.y
   };
-  return [center2.x - size.x, center2.y - size.y, center2.x + size.x, center2.y + size.y];
+  return [center2.x - size2.x, center2.y - size2.y, center2.x + size2.x, center2.y + size2.y];
 }
 class MaskEffect {
   constructor() {
@@ -60799,13 +61786,13 @@ class ShaderAttribute {
       value
     } = this.source;
     const {
-      size
+      size: size2
     } = accessor;
     let constantValue = value;
-    if (value && value.length !== size) {
-      constantValue = new Float32Array(size);
+    if (value && value.length !== size2) {
+      constantValue = new Float32Array(size2);
       const index2 = accessor.elementOffset || 0;
-      for (let i2 = 0; i2 < size; ++i2) {
+      for (let i2 = 0; i2 < size2; ++i2) {
         constantValue[i2] = value[index2 + i2];
       }
     }
@@ -61008,14 +61995,14 @@ class DataColumn {
       const {
         value,
         numInstances,
-        size
+        size: size2
       } = this;
-      const len2 = numInstances * size;
+      const len2 = numInstances * size2;
       if (value && len2 && value.length >= len2) {
-        const min = new Array(size).fill(Infinity);
-        const max2 = new Array(size).fill(-Infinity);
+        const min = new Array(size2).fill(Infinity);
+        const max2 = new Array(size2).fill(-Infinity);
         for (let i2 = 0; i2 < len2; ) {
-          for (let j = 0; j < size; j++) {
+          for (let j = 0; j < size2; j++) {
             const v = value[i2++];
             if (v < min[j]) min[j] = v;
             if (v > max2[j]) max2[j] = v;
@@ -61181,7 +62168,7 @@ class DataColumn {
   _normalizeValue(value, out, start) {
     const {
       defaultValue: defaultValue2,
-      size
+      size: size2
     } = this.settings;
     if (Number.isFinite(value)) {
       out[start] = value;
@@ -61191,7 +62178,7 @@ class DataColumn {
       out[start] = defaultValue2[0];
       return out;
     }
-    switch (size) {
+    switch (size2) {
       case 4:
         out[start + 3] = Number.isFinite(value[3]) ? value[3] : defaultValue2[3];
       case 3:
@@ -61202,7 +62189,7 @@ class DataColumn {
         out[start + 0] = Number.isFinite(value[0]) ? value[0] : defaultValue2[0];
         break;
       default:
-        let i2 = size;
+        let i2 = size2;
         while (--i2 >= 0) {
           out[start + i2] = Number.isFinite(value[i2]) ? value[i2] : defaultValue2[i2];
         }
@@ -61214,9 +62201,9 @@ class DataColumn {
       return false;
     }
     const {
-      size
+      size: size2
     } = this;
-    for (let i2 = 0; i2 < size; i2++) {
+    for (let i2 = 0; i2 < size2; i2++) {
       if (value1[i2] !== value2[i2]) {
         return false;
       }
@@ -61255,14 +62242,14 @@ function isAsyncIterable(data) {
 }
 function getAccessorFromBuffer(typedArray, options) {
   const {
-    size,
+    size: size2,
     stride,
     offset: offset2,
     startIndices,
     nested: nested2
   } = options;
   const bytesPerElement = typedArray.BYTES_PER_ELEMENT;
-  const elementStride = stride ? stride / bytesPerElement : size;
+  const elementStride = stride ? stride / bytesPerElement : size2;
   const elementOffset = offset2 ? offset2 / bytesPerElement : 0;
   const vertexCount = Math.floor((typedArray.length - elementOffset) / elementStride);
   return (_, {
@@ -61271,7 +62258,7 @@ function getAccessorFromBuffer(typedArray, options) {
   }) => {
     if (!startIndices) {
       const sourceIndex = index2 * elementStride + elementOffset;
-      for (let j = 0; j < size; j++) {
+      for (let j = 0; j < size2; j++) {
         target[j] = typedArray[sourceIndex + j];
       }
       return target;
@@ -61283,20 +62270,20 @@ function getAccessorFromBuffer(typedArray, options) {
       result = new Array(endIndex - startIndex);
       for (let i2 = startIndex; i2 < endIndex; i2++) {
         const sourceIndex = i2 * elementStride + elementOffset;
-        target = new Array(size);
-        for (let j = 0; j < size; j++) {
+        target = new Array(size2);
+        for (let j = 0; j < size2; j++) {
           target[j] = typedArray[sourceIndex + j];
         }
         result[i2 - startIndex] = target;
       }
-    } else if (elementStride === size) {
-      result = typedArray.subarray(startIndex * size + elementOffset, endIndex * size + elementOffset);
+    } else if (elementStride === size2) {
+      result = typedArray.subarray(startIndex * size2 + elementOffset, endIndex * size2 + elementOffset);
     } else {
-      result = new typedArray.constructor((endIndex - startIndex) * size);
+      result = new typedArray.constructor((endIndex - startIndex) * size2);
       let targetIndex = 0;
       for (let i2 = startIndex; i2 < endIndex; i2++) {
         const sourceIndex = i2 * elementStride + elementOffset;
-        for (let j = 0; j < size; j++) {
+        for (let j = 0; j < size2; j++) {
           result[targetIndex++] = typedArray[sourceIndex + j];
         }
       }
@@ -61338,7 +62325,7 @@ function padArrayChunk(options) {
     source,
     target,
     start = 0,
-    size,
+    size: size2,
     getData
   } = options;
   const end = options.end || target.length;
@@ -61355,7 +62342,7 @@ function padArrayChunk(options) {
   let i2 = sourceLength;
   while (i2 < targetLength) {
     const datum2 = getData(i2, source);
-    for (let j = 0; j < size; j++) {
+    for (let j = 0; j < size2; j++) {
       target[start + i2] = datum2[j] || 0;
       i2++;
     }
@@ -61364,7 +62351,7 @@ function padArrayChunk(options) {
 function padArray({
   source,
   target,
-  size,
+  size: size2,
   getData,
   sourceStartIndices,
   targetStartIndices
@@ -61373,7 +62360,7 @@ function padArray({
     padArrayChunk({
       source,
       target,
-      size,
+      size: size2,
       getData
     });
     return target;
@@ -61383,14 +62370,14 @@ function padArray({
   const getChunkData = getData && ((i2, chunk) => getData(i2 + targetIndex, chunk));
   const n2 = Math.min(sourceStartIndices.length, targetStartIndices.length);
   for (let i2 = 1; i2 < n2; i2++) {
-    const nextSourceIndex = sourceStartIndices[i2] * size;
-    const nextTargetIndex = targetStartIndices[i2] * size;
+    const nextSourceIndex = sourceStartIndices[i2] * size2;
+    const nextTargetIndex = targetStartIndices[i2] * size2;
     padArrayChunk({
       source: source.subarray(sourceIndex, nextSourceIndex),
       target,
       start: targetIndex,
       end: nextTargetIndex,
-      size,
+      size: size2,
       getData: getChunkData
     });
     sourceIndex = nextSourceIndex;
@@ -61401,7 +62388,7 @@ function padArray({
       source: [],
       target,
       start: targetIndex,
-      size,
+      size: size2,
       getData: getChunkData
     });
   }
@@ -61446,8 +62433,8 @@ function getSourceBufferAttribute(gl, attribute) {
   }
   return attribute.value;
 }
-function getAttributeTypeFromSize(size) {
-  switch (size) {
+function getAttributeTypeFromSize(size2) {
+  switch (size2) {
     case 1:
       return "float";
     case 2:
@@ -61457,7 +62444,7 @@ function getAttributeTypeFromSize(size) {
     case 4:
       return "vec4";
     default:
-      throw new Error('No defined attribute type for size "'.concat(size, '"'));
+      throw new Error('No defined attribute type for size "'.concat(size2, '"'));
   }
 }
 function cycleBuffers(buffers) {
@@ -61468,10 +62455,10 @@ function getAttributeBufferLength(attribute, numInstances) {
     doublePrecision,
     settings,
     value,
-    size
+    size: size2
   } = attribute;
   const multiplier = doublePrecision && value instanceof Float64Array ? 2 : 1;
-  return (settings.noAlloc ? value.length : numInstances * size) * multiplier;
+  return (settings.noAlloc ? value.length : numInstances * size2) * multiplier;
 }
 function padBuffer({
   buffer,
@@ -61482,7 +62469,7 @@ function padBuffer({
   getData = (x) => x
 }) {
   const precisionMultiplier = attribute.doublePrecision && attribute.value instanceof Float64Array ? 2 : 1;
-  const size = attribute.size * precisionMultiplier;
+  const size2 = attribute.size * precisionMultiplier;
   const byteOffset = attribute.byteOffset;
   const toStartIndices = attribute.startIndices;
   const hasStartIndices = fromStartIndices && toStartIndices;
@@ -61498,7 +62485,7 @@ function padBuffer({
     const getter = getData;
     getData = (value, chunk) => attribute.normalizeConstant(getter(value, chunk));
   }
-  const getMissingData = isConstant ? (i2, chunk) => getData(toData, chunk) : (i2, chunk) => getData(toData.subarray(i2, i2 + size), chunk);
+  const getMissingData = isConstant ? (i2, chunk) => getData(toData, chunk) : (i2, chunk) => getData(toData.subarray(i2, i2 + size2), chunk);
   const source = buffer.getData({
     length: fromLength
   });
@@ -61508,7 +62495,7 @@ function padBuffer({
     target: data,
     sourceStartIndices: fromStartIndices,
     targetStartIndices: toStartIndices,
-    size,
+    size: size2,
     getData: getMissingData
   });
   if (buffer.byteLength < data.byteLength + byteOffset) {
@@ -61764,7 +62751,7 @@ class Attribute extends DataColumn {
       settings,
       state,
       value,
-      size,
+      size: size2,
       startIndices
     } = attribute;
     const {
@@ -61790,9 +62777,9 @@ class Attribute extends DataColumn {
           let startIndex = i2;
           for (const item of objectValue) {
             attribute._normalizeValue(item, value, startIndex);
-            startIndex += size;
+            startIndex += size2;
           }
-        } else if (objectValue && objectValue.length > size) {
+        } else if (objectValue && objectValue.length > size2) {
           value.set(objectValue, i2);
         } else {
           attribute._normalizeValue(objectValue, objectInfo.target, 0);
@@ -61803,10 +62790,10 @@ class Attribute extends DataColumn {
             count: numVertices
           });
         }
-        i2 += numVertices * size;
+        i2 += numVertices * size2;
       } else {
         attribute._normalizeValue(objectValue, value, i2);
-        i2 += size;
+        i2 += size2;
       }
     }
   }
@@ -67004,14 +67991,14 @@ function reversePolygon(points, options) {
   const {
     start = 0,
     end = points.length,
-    size = 2
+    size: size2 = 2
   } = options;
-  const numPoints = (end - start) / size;
+  const numPoints = (end - start) / size2;
   const numSwaps = Math.floor(numPoints / 2);
   for (let i2 = 0; i2 < numSwaps; ++i2) {
-    const b1 = start + i2 * size;
-    const b2 = start + (numPoints - 1 - i2) * size;
-    for (let j = 0; j < size; ++j) {
+    const b1 = start + i2 * size2;
+    const b2 = start + (numPoints - 1 - i2) * size2;
+    for (let j = 0; j < size2; ++j) {
       const tmp = points[b1 + j];
       points[b1 + j] = points[b2 + j];
       points[b2 + j] = tmp;
@@ -67019,12 +68006,12 @@ function reversePolygon(points, options) {
   }
 }
 function push(target, source) {
-  const size = source.length;
+  const size2 = source.length;
   const startIndex = target.length;
   if (startIndex > 0) {
     let isDuplicate = true;
-    for (let i2 = 0; i2 < size; i2++) {
-      if (target[startIndex - size + i2] !== source[i2]) {
+    for (let i2 = 0; i2 < size2; i2++) {
+      if (target[startIndex - size2 + i2] !== source[i2]) {
         isDuplicate = false;
         break;
       }
@@ -67033,20 +68020,20 @@ function push(target, source) {
       return false;
     }
   }
-  for (let i2 = 0; i2 < size; i2++) {
+  for (let i2 = 0; i2 < size2; i2++) {
     target[startIndex + i2] = source[i2];
   }
   return true;
 }
 function copy(target, source) {
-  const size = source.length;
-  for (let i2 = 0; i2 < size; i2++) {
+  const size2 = source.length;
+  for (let i2 = 0; i2 < size2; i2++) {
     target[i2] = source[i2];
   }
 }
-function getPointAtIndex(positions, index2, size, offset2, out = []) {
-  const startI = offset2 + index2 * size;
-  for (let i2 = 0; i2 < size; i2++) {
+function getPointAtIndex(positions, index2, size2, offset2, out = []) {
+  const startI = offset2 + index2 * size2;
+  for (let i2 = 0; i2 < size2; i2++) {
     out[i2] = positions[startI + i2];
   }
   return out;
@@ -67084,24 +68071,24 @@ function bitCode(p, bbox2) {
 }
 function cutPolylineByGrid(positions, options) {
   const {
-    size = 2,
+    size: size2 = 2,
     broken = false,
     gridResolution = 10,
     gridOffset = [0, 0],
     startIndex = 0,
     endIndex = positions.length
   } = options || {};
-  const numPoints = (endIndex - startIndex) / size;
+  const numPoints = (endIndex - startIndex) / size2;
   let part = [];
   const result = [part];
-  const a2 = getPointAtIndex(positions, 0, size, startIndex);
+  const a2 = getPointAtIndex(positions, 0, size2, startIndex);
   let b;
   let codeB;
   const cell = getGridCell(a2, gridResolution, gridOffset, []);
   const scratchPoint = [];
   push(part, a2);
   for (let i2 = 1; i2 < numPoints; i2++) {
-    b = getPointAtIndex(positions, i2, size, startIndex, b);
+    b = getPointAtIndex(positions, i2, size2, startIndex, b);
     codeB = bitCode(b, cell);
     while (codeB) {
       intersect(a2, b, codeB, cell, scratchPoint);
@@ -67113,7 +68100,7 @@ function cutPolylineByGrid(positions, options) {
       push(part, scratchPoint);
       copy(a2, scratchPoint);
       moveToNeighborCell(cell, gridResolution, codeB);
-      if (broken && part.length > size) {
+      if (broken && part.length > size2) {
         part = [];
         result.push(part);
         push(part, a2);
@@ -67138,7 +68125,7 @@ function cutPolygonByGrid(positions, holeIndices = null, options) {
     return [];
   }
   const {
-    size = 2,
+    size: size2 = 2,
     gridResolution = 10,
     gridOffset = [0, 0],
     edgeTypes = false
@@ -67146,7 +68133,7 @@ function cutPolygonByGrid(positions, holeIndices = null, options) {
   const result = [];
   const queue = [{
     pos: positions,
-    types: edgeTypes ? new Array(positions.length / size).fill(TYPE_BORDER) : null,
+    types: edgeTypes ? new Array(positions.length / size2).fill(TYPE_BORDER) : null,
     holes: holeIndices || []
   }];
   const bbox2 = [[], []];
@@ -67157,11 +68144,11 @@ function cutPolygonByGrid(positions, holeIndices = null, options) {
       types,
       holes
     } = queue.shift();
-    getBoundingBox$2(pos, size, holes[0] || pos.length, bbox2);
+    getBoundingBox$2(pos, size2, holes[0] || pos.length, bbox2);
     cell = getGridCell(bbox2[0], gridResolution, gridOffset, cell);
     const code = bitCode(bbox2[1], cell);
     if (code) {
-      let parts = bisectPolygon(pos, types, size, 0, holes[0] || pos.length, cell, code);
+      let parts = bisectPolygon(pos, types, size2, 0, holes[0] || pos.length, cell, code);
       const polygonLow = {
         pos: parts[0].pos,
         types: parts[0].types,
@@ -67174,7 +68161,7 @@ function cutPolygonByGrid(positions, holeIndices = null, options) {
       };
       queue.push(polygonLow, polygonHigh);
       for (let i2 = 0; i2 < holes.length; i2++) {
-        parts = bisectPolygon(pos, types, size, holes[i2], holes[i2 + 1] || pos.length, cell, code);
+        parts = bisectPolygon(pos, types, size2, holes[i2], holes[i2 + 1] || pos.length, cell, code);
         if (parts[0]) {
           polygonLow.holes.push(polygonLow.pos.length);
           polygonLow.pos = concatInPlace(polygonLow.pos, parts[0].pos);
@@ -67205,8 +68192,8 @@ function cutPolygonByGrid(positions, holeIndices = null, options) {
   }
   return result;
 }
-function bisectPolygon(positions, edgeTypes, size, startIndex, endIndex, bbox2, edge) {
-  const numPoints = (endIndex - startIndex) / size;
+function bisectPolygon(positions, edgeTypes, size2, startIndex, endIndex, bbox2, edge) {
+  const numPoints = (endIndex - startIndex) / size2;
   const resultLow = [];
   const resultHigh = [];
   const typesLow = [];
@@ -67215,15 +68202,15 @@ function bisectPolygon(positions, edgeTypes, size, startIndex, endIndex, bbox2,
   let p;
   let side;
   let type;
-  const prev2 = getPointAtIndex(positions, numPoints - 1, size, startIndex);
+  const prev2 = getPointAtIndex(positions, numPoints - 1, size2, startIndex);
   let prevSide = Math.sign(edge & 8 ? prev2[1] - bbox2[3] : prev2[0] - bbox2[2]);
   let prevType = edgeTypes && edgeTypes[numPoints - 1];
   let lowPointCount = 0;
   let highPointCount = 0;
   for (let i2 = 0; i2 < numPoints; i2++) {
-    p = getPointAtIndex(positions, i2, size, startIndex, p);
+    p = getPointAtIndex(positions, i2, size2, startIndex, p);
     side = Math.sign(edge & 8 ? p[1] - bbox2[3] : p[0] - bbox2[2]);
-    type = edgeTypes && edgeTypes[startIndex / size + i2];
+    type = edgeTypes && edgeTypes[startIndex / size2 + i2];
     if (side && prevSide && prevSide !== side) {
       intersect(prev2, p, edge, bbox2, scratchPoint);
       push(resultLow, scratchPoint) && typesLow.push(prevType);
@@ -67277,12 +68264,12 @@ function moveToNeighborCell(cell, gridResolution, edge) {
     cell[2] -= gridResolution;
   }
 }
-function getBoundingBox$2(positions, size, endIndex, out) {
+function getBoundingBox$2(positions, size2, endIndex, out) {
   let minX = Infinity;
   let maxX = -Infinity;
   let minY = Infinity;
   let maxY = -Infinity;
-  for (let i2 = 0; i2 < endIndex; i2 += size) {
+  for (let i2 = 0; i2 < endIndex; i2 += size2) {
     const x = positions[i2];
     const y = positions[i2 + 1];
     minX = x < minX ? x : minX;
@@ -67299,29 +68286,29 @@ function getBoundingBox$2(positions, size, endIndex, out) {
 const DEFAULT_MAX_LATITUDE = 85.051129;
 function cutPolylineByMercatorBounds(positions, options) {
   const {
-    size = 2,
+    size: size2 = 2,
     startIndex = 0,
     endIndex = positions.length,
     normalize: normalize2 = true
   } = options || {};
   const newPositions = positions.slice(startIndex, endIndex);
-  wrapLongitudesForShortestPath(newPositions, size, 0, endIndex - startIndex);
+  wrapLongitudesForShortestPath(newPositions, size2, 0, endIndex - startIndex);
   const parts = cutPolylineByGrid(newPositions, {
-    size,
+    size: size2,
     broken: true,
     gridResolution: 360,
     gridOffset: [-180, -180]
   });
   if (normalize2) {
     for (const part of parts) {
-      shiftLongitudesIntoRange(part, size);
+      shiftLongitudesIntoRange(part, size2);
     }
   }
   return parts;
 }
 function cutPolygonByMercatorBounds(positions, holeIndices = null, options) {
   const {
-    size = 2,
+    size: size2 = 2,
     normalize: normalize2 = true,
     edgeTypes = false
   } = options || {};
@@ -67333,36 +68320,36 @@ function cutPolygonByMercatorBounds(positions, holeIndices = null, options) {
   for (let ringIndex = 0; ringIndex <= holeIndices.length; ringIndex++) {
     const srcEndIndex = holeIndices[ringIndex] || positions.length;
     const targetStartIndex = targetIndex;
-    const splitIndex = findSplitIndex(positions, size, srcStartIndex, srcEndIndex);
+    const splitIndex = findSplitIndex(positions, size2, srcStartIndex, srcEndIndex);
     for (let i2 = splitIndex; i2 < srcEndIndex; i2++) {
       newPositions[targetIndex++] = positions[i2];
     }
     for (let i2 = srcStartIndex; i2 < splitIndex; i2++) {
       newPositions[targetIndex++] = positions[i2];
     }
-    wrapLongitudesForShortestPath(newPositions, size, targetStartIndex, targetIndex);
-    insertPoleVertices(newPositions, size, targetStartIndex, targetIndex, options === null || options === void 0 ? void 0 : options.maxLatitude);
+    wrapLongitudesForShortestPath(newPositions, size2, targetStartIndex, targetIndex);
+    insertPoleVertices(newPositions, size2, targetStartIndex, targetIndex, options === null || options === void 0 ? void 0 : options.maxLatitude);
     srcStartIndex = srcEndIndex;
     newHoleIndices[ringIndex] = targetIndex;
   }
   newHoleIndices.pop();
   const parts = cutPolygonByGrid(newPositions, newHoleIndices, {
-    size,
+    size: size2,
     gridResolution: 360,
     gridOffset: [-180, -180],
     edgeTypes
   });
   if (normalize2) {
     for (const part of parts) {
-      shiftLongitudesIntoRange(part.positions, size);
+      shiftLongitudesIntoRange(part.positions, size2);
     }
   }
   return parts;
 }
-function findSplitIndex(positions, size, startIndex, endIndex) {
+function findSplitIndex(positions, size2, startIndex, endIndex) {
   let maxLat = -1;
   let pointIndex = -1;
-  for (let i2 = startIndex + 1; i2 < endIndex; i2 += size) {
+  for (let i2 = startIndex + 1; i2 < endIndex; i2 += size2) {
     const lat = Math.abs(positions[i2]);
     if (lat > maxLat) {
       maxLat = lat;
@@ -67371,11 +68358,11 @@ function findSplitIndex(positions, size, startIndex, endIndex) {
   }
   return pointIndex;
 }
-function insertPoleVertices(positions, size, startIndex, endIndex, maxLatitude = DEFAULT_MAX_LATITUDE) {
+function insertPoleVertices(positions, size2, startIndex, endIndex, maxLatitude = DEFAULT_MAX_LATITUDE) {
   const firstLng = positions[startIndex];
-  const lastLng = positions[endIndex - size];
+  const lastLng = positions[endIndex - size2];
   if (Math.abs(firstLng - lastLng) > 180) {
-    const p = getPointAtIndex(positions, 0, size, startIndex);
+    const p = getPointAtIndex(positions, 0, size2, startIndex);
     p[0] += Math.round((lastLng - firstLng) / 360) * 360;
     push(positions, p);
     p[1] = Math.sign(p[1]) * maxLatitude;
@@ -67384,10 +68371,10 @@ function insertPoleVertices(positions, size, startIndex, endIndex, maxLatitude =
     push(positions, p);
   }
 }
-function wrapLongitudesForShortestPath(positions, size, startIndex, endIndex) {
+function wrapLongitudesForShortestPath(positions, size2, startIndex, endIndex) {
   let prevLng = positions[0];
   let lng;
-  for (let i2 = startIndex; i2 < endIndex; i2 += size) {
+  for (let i2 = startIndex; i2 < endIndex; i2 += size2) {
     lng = positions[i2];
     const delta = lng - prevLng;
     if (delta > 180 || delta < -180) {
@@ -67396,11 +68383,11 @@ function wrapLongitudesForShortestPath(positions, size, startIndex, endIndex) {
     positions[i2] = prevLng = lng;
   }
 }
-function shiftLongitudesIntoRange(positions, size) {
+function shiftLongitudesIntoRange(positions, size2) {
   let refLng;
-  const pointCount = positions.length / size;
+  const pointCount = positions.length / size2;
   for (let i2 = 0; i2 < pointCount; i2++) {
-    refLng = positions[i2 * size];
+    refLng = positions[i2 * size2];
     if ((refLng + 180) % 360 !== 0) {
       break;
     }
@@ -67410,7 +68397,7 @@ function shiftLongitudesIntoRange(positions, size) {
     return;
   }
   for (let i2 = 0; i2 < pointCount; i2++) {
-    positions[i2 * size] += delta;
+    positions[i2 * size2] += delta;
   }
 }
 class ColumnGeometry extends Geometry {
@@ -67809,14 +68796,14 @@ class GridCellLayer extends ColumnLayer {
 }
 _defineProperty(GridCellLayer, "layerName", "GridCellLayer");
 _defineProperty(GridCellLayer, "defaultProps", defaultProps$E);
-function normalizePath(path, size, gridResolution, wrapLongitude) {
+function normalizePath(path, size2, gridResolution, wrapLongitude) {
   let flatPath;
   if (Array.isArray(path[0])) {
-    const length2 = path.length * size;
+    const length2 = path.length * size2;
     flatPath = new Array(length2);
     for (let i2 = 0; i2 < path.length; i2++) {
-      for (let j = 0; j < size; j++) {
-        flatPath[i2 * size + j] = path[i2][j] || 0;
+      for (let j = 0; j < size2; j++) {
+        flatPath[i2 * size2 + j] = path[i2][j] || 0;
       }
     }
   } else {
@@ -67824,13 +68811,13 @@ function normalizePath(path, size, gridResolution, wrapLongitude) {
   }
   if (gridResolution) {
     return cutPolylineByGrid(flatPath, {
-      size,
+      size: size2,
       gridResolution
     });
   }
   if (wrapLongitude) {
     return cutPolylineByMercatorBounds(flatPath, {
-      size
+      size: size2
     });
   }
   return flatPath;
@@ -67873,11 +68860,11 @@ class PathTesselator extends Tesselator {
   }
   getGeometrySize(path) {
     if (isCut$1(path)) {
-      let size = 0;
+      let size2 = 0;
       for (const subPath of path) {
-        size += this.getGeometrySize(subPath);
+        size2 += this.getGeometrySize(subPath);
       }
-      return size;
+      return size2;
     }
     const numPoints = this.getPathLength(path);
     if (numPoints < 2) {
@@ -68685,34 +69672,34 @@ function isNestedRingClosed(simplePolygon) {
   const p1 = simplePolygon[simplePolygon.length - 1];
   return p02[0] === p1[0] && p02[1] === p1[1] && p02[2] === p1[2];
 }
-function isFlatRingClosed(positions, size, startIndex, endIndex) {
-  for (let i2 = 0; i2 < size; i2++) {
-    if (positions[startIndex + i2] !== positions[endIndex - size + i2]) {
+function isFlatRingClosed(positions, size2, startIndex, endIndex) {
+  for (let i2 = 0; i2 < size2; i2++) {
+    if (positions[startIndex + i2] !== positions[endIndex - size2 + i2]) {
       return false;
     }
   }
   return true;
 }
-function copyNestedRing(target, targetStartIndex, simplePolygon, size, windingDirection) {
+function copyNestedRing(target, targetStartIndex, simplePolygon, size2, windingDirection) {
   let targetIndex = targetStartIndex;
   const len2 = simplePolygon.length;
   for (let i2 = 0; i2 < len2; i2++) {
-    for (let j = 0; j < size; j++) {
+    for (let j = 0; j < size2; j++) {
       target[targetIndex++] = simplePolygon[i2][j] || 0;
     }
   }
   if (!isNestedRingClosed(simplePolygon)) {
-    for (let j = 0; j < size; j++) {
+    for (let j = 0; j < size2; j++) {
       target[targetIndex++] = simplePolygon[0][j] || 0;
     }
   }
   windingOptions.start = targetStartIndex;
   windingOptions.end = targetIndex;
-  windingOptions.size = size;
+  windingOptions.size = size2;
   modifyPolygonWindingDirection(target, windingDirection, windingOptions);
   return targetIndex;
 }
-function copyFlatRing(target, targetStartIndex, positions, size, srcStartIndex = 0, srcEndIndex, windingDirection) {
+function copyFlatRing(target, targetStartIndex, positions, size2, srcStartIndex = 0, srcEndIndex, windingDirection) {
   srcEndIndex = srcEndIndex || positions.length;
   const srcLength = srcEndIndex - srcStartIndex;
   if (srcLength <= 0) {
@@ -68722,14 +69709,14 @@ function copyFlatRing(target, targetStartIndex, positions, size, srcStartIndex =
   for (let i2 = 0; i2 < srcLength; i2++) {
     target[targetIndex++] = positions[srcStartIndex + i2];
   }
-  if (!isFlatRingClosed(positions, size, srcStartIndex, srcEndIndex)) {
-    for (let i2 = 0; i2 < size; i2++) {
+  if (!isFlatRingClosed(positions, size2, srcStartIndex, srcEndIndex)) {
+    for (let i2 = 0; i2 < size2; i2++) {
       target[targetIndex++] = positions[srcStartIndex + i2];
     }
   }
   windingOptions.start = targetStartIndex;
   windingOptions.end = targetIndex;
-  windingOptions.size = size;
+  windingOptions.size = size2;
   modifyPolygonWindingDirection(target, windingDirection, windingOptions);
   return targetIndex;
 }
@@ -68860,11 +69847,11 @@ class PolygonTesselator extends Tesselator {
   }
   getGeometrySize(polygon2) {
     if (isCut(polygon2)) {
-      let size = 0;
+      let size2 = 0;
       for (const subPolygon of polygon2) {
-        size += this.getGeometrySize(subPolygon);
+        size2 += this.getGeometrySize(subPolygon);
       }
-      return size;
+      return size2;
     }
     return getPositions(polygon2).length / this.positionSize;
   }
@@ -69735,10 +70722,10 @@ function requireTinySdf() {
     this.fontFamily = fontFamily || "sans-serif";
     this.fontWeight = fontWeight || "normal";
     this.radius = radius || 8;
-    var size = this.size = this.fontSize + this.buffer * 2;
-    var gridSize = size + this.buffer * 2;
+    var size2 = this.size = this.fontSize + this.buffer * 2;
+    var gridSize = size2 + this.buffer * 2;
     this.canvas = document.createElement("canvas");
-    this.canvas.width = this.canvas.height = size;
+    this.canvas.width = this.canvas.height = size2;
     this.ctx = this.canvas.getContext("2d");
     this.ctx.font = this.fontWeight + " " + this.fontSize + "px " + this.fontFamily;
     this.ctx.textAlign = "left";
@@ -69749,7 +70736,7 @@ function requireTinySdf() {
     this.z = new Float64Array(gridSize + 1);
     this.v = new Uint16Array(gridSize);
     this.useMetrics = this.ctx.measureText("A").actualBoundingBoxLeft !== void 0;
-    this.middle = Math.round(size / 2 * (navigator.userAgent.indexOf("Gecko/") >= 0 ? 1.2 : 1));
+    this.middle = Math.round(size2 / 2 * (navigator.userAgent.indexOf("Gecko/") >= 0 ? 1.2 : 1));
   }
   function prepareGrids(imgData, width2, height2, glyphWidth, glyphHeight, gridOuter, gridInner) {
     gridOuter.fill(INF, 0, width2 * height2);
@@ -70006,7 +70993,7 @@ function transformParagraph(paragraph, lineHeight, wordBreak, maxWidth2, iconMap
   const y = new Array(numCharacters);
   const rowWidth = new Array(numCharacters);
   const autoWrappingEnabled = (wordBreak === "break-word" || wordBreak === "break-all") && isFinite(maxWidth2) && maxWidth2 > 0;
-  const size = [0, 0];
+  const size2 = [0, 0];
   const rowSize = [0, 0];
   let rowOffsetTop = 0;
   let lineStartIndex = 0;
@@ -70027,7 +71014,7 @@ function transformParagraph(paragraph, lineHeight, wordBreak, maxWidth2, iconMap
           rowWidth[j] = rowSize[0];
         }
         rowOffsetTop = rowOffsetTop + rowSize[1] * lineHeight;
-        size[0] = Math.max(size[0], rowSize[0]);
+        size2[0] = Math.max(size2[0], rowSize[0]);
       }
       lineStartIndex = lineEndIndex;
     }
@@ -70038,12 +71025,12 @@ function transformParagraph(paragraph, lineHeight, wordBreak, maxWidth2, iconMap
       lineStartIndex++;
     }
   }
-  size[1] = rowOffsetTop;
+  size2[1] = rowOffsetTop;
   return {
     x,
     y,
     rowWidth,
-    size
+    size: size2
   };
 }
 function getTextFromBuffer({
@@ -71704,14 +72691,14 @@ class GPUGridAggregator {
   }
   static getCellData({
     countsData,
-    size = 1
+    size: size2 = 1
   }) {
     const numCells = countsData.length / 4;
-    const cellWeights = new Float32Array(numCells * size);
+    const cellWeights = new Float32Array(numCells * size2);
     const cellCounts = new Uint32Array(numCells);
     for (let i2 = 0; i2 < numCells; i2++) {
-      for (let sizeIndex = 0; sizeIndex < size; sizeIndex++) {
-        cellWeights[i2 * size + sizeIndex] = countsData[i2 * 4 + sizeIndex];
+      for (let sizeIndex = 0; sizeIndex < size2; sizeIndex++) {
+        cellWeights[i2 * size2 + sizeIndex] = countsData[i2 * 4 + sizeIndex];
       }
       cellCounts[i2] = countsData[i2 * 4 + 3];
     }
@@ -72692,7 +73679,7 @@ function pointsToGridHashing(props, aggregationParams) {
   } = aggregationParams;
   const positions = attributes.positions.value;
   const {
-    size
+    size: size2
   } = attributes.positions.getAccessor();
   const boundingBox = aggregationParams.boundingBox || getPositionBoundingBox(attributes.positions, numInstances);
   const offsets = aggregationParams.posOffset || [180, 90];
@@ -72717,9 +73704,9 @@ function pointsToGridHashing(props, aggregationParams) {
   const position2 = new Array(3);
   for (const pt of iterable) {
     objectInfo.index++;
-    position2[0] = positions[objectInfo.index * size];
-    position2[1] = positions[objectInfo.index * size + 1];
-    position2[2] = size >= 3 ? positions[objectInfo.index * size + 2] : 0;
+    position2[0] = positions[objectInfo.index * size2];
+    position2[1] = positions[objectInfo.index * size2 + 1];
+    position2[2] = size2 >= 3 ? positions[objectInfo.index * size2 + 2] : 0;
     const [x, y] = projectPoints ? viewport.project(position2) : position2;
     if (Number.isFinite(x) && Number.isFinite(y)) {
       const yIndex = Math.floor((y + offsets[1]) / gridOffset.yOffset);
@@ -72769,7 +73756,7 @@ function getGridLayerDataFromGridHash({
 function getPositionBoundingBox(positionAttribute, numInstance) {
   const positions = positionAttribute.value;
   const {
-    size
+    size: size2
   } = positionAttribute.getAccessor();
   let yMin = Infinity;
   let yMax = -Infinity;
@@ -72778,8 +73765,8 @@ function getPositionBoundingBox(positionAttribute, numInstance) {
   let y;
   let x;
   for (let i2 = 0; i2 < numInstance; i2++) {
-    x = positions[i2 * size];
-    y = positions[i2 * size + 1];
+    x = positions[i2 * size2];
+    y = positions[i2 * size2 + 1];
     if (Number.isFinite(x) && Number.isFinite(y)) {
       yMin = y < yMin ? y : yMin;
       yMax = y > yMax ? y : yMax;
@@ -73872,9 +74859,9 @@ function requireLong() {
         var radixToPower = fromNumber(pow_dbl(radix, 8));
         var result = ZERO2;
         for (var i2 = 0; i2 < str.length; i2 += 8) {
-          var size = Math.min(8, str.length - i2), value = parseInt(str.substring(i2, i2 + size), radix);
-          if (size < 8) {
-            var power = fromNumber(pow_dbl(radix, size));
+          var size2 = Math.min(8, str.length - i2), value = parseInt(str.substring(i2, i2 + size2), radix);
+          if (size2 < 8) {
+            var power = fromNumber(pow_dbl(radix, size2));
             result = result.mul(power).add(fromNumber(value));
           } else {
             result = result.mul(radixToPower);
@@ -76792,10 +77779,10 @@ var libh3 = function(libh32) {
   function abortOnCannotGrowMemory(requestedSize) {
     abort("OOM");
   }
-  function emscripten_realloc_buffer(size) {
+  function emscripten_realloc_buffer(size2) {
     try {
-      var newBuffer = new ArrayBuffer(size);
-      if (newBuffer.byteLength != size) {
+      var newBuffer = new ArrayBuffer(size2);
+      if (newBuffer.byteLength != size2) {
         return;
       }
       new Int8Array(newBuffer).set(HEAP8);
@@ -89729,8 +90716,8 @@ const ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
   5125: Uint32Array,
   5126: Float32Array
 };
-function getAccessorTypeFromSize(size) {
-  const type = TYPES[size - 1];
+function getAccessorTypeFromSize(size2) {
+  const type = TYPES[size2 - 1];
   return type || TYPES[0];
 }
 function getComponentTypeFromArray(typedArray) {
@@ -90147,23 +91134,23 @@ class GLTFScenegraph {
         return attributeName;
     }
   }
-  _getAccessorMinMax(buffer, size) {
+  _getAccessorMinMax(buffer, size2) {
     const result = {
       min: null,
       max: null
     };
-    if (buffer.length < size) {
+    if (buffer.length < size2) {
       return result;
     }
     result.min = [];
     result.max = [];
-    const initValues = buffer.subarray(0, size);
+    const initValues = buffer.subarray(0, size2);
     for (const value of initValues) {
       result.min.push(value);
       result.max.push(value);
     }
-    for (let index2 = size; index2 < buffer.length; index2 += size) {
-      for (let componentIndex = 0; componentIndex < size; componentIndex++) {
+    for (let index2 = size2; index2 < buffer.length; index2 += size2) {
+      for (let componentIndex = 0; componentIndex < size2; componentIndex++) {
         result.min[0 + componentIndex] = Math.min(result.min[0 + componentIndex], buffer[index2 + componentIndex]);
         result.max[0 + componentIndex] = Math.max(result.max[0 + componentIndex], buffer[index2 + componentIndex]);
       }
@@ -90193,9 +91180,9 @@ const DECODERS = {
   TRIANGLES: "meshopt_decodeIndexBuffer",
   INDICES: "meshopt_decodeIndexSequence"
 };
-async function meshoptDecodeGltfBuffer(target, count2, size, source, mode, filter2 = "NONE") {
+async function meshoptDecodeGltfBuffer(target, count2, size2, source, mode, filter2 = "NONE") {
   const instance = await loadWasmInstance();
-  decode$5(instance, instance.exports[DECODERS[mode]], target, count2, size, source, instance.exports[FILTERS[filter2 || "NONE"]]);
+  decode$5(instance, instance.exports[DECODERS[mode]], target, count2, size2, source, instance.exports[FILTERS[filter2 || "NONE"]]);
 }
 let wasmPromise;
 async function loadWasmInstance() {
@@ -90226,18 +91213,18 @@ function unpack(data) {
   }
   return result.buffer.slice(0, write);
 }
-function decode$5(instance, fun, target, count2, size, source, filter2) {
+function decode$5(instance, fun, target, count2, size2, source, filter2) {
   const sbrk = instance.exports.sbrk;
   const count4 = count2 + 3 & -4;
-  const tp = sbrk(count4 * size);
+  const tp = sbrk(count4 * size2);
   const sp = sbrk(source.length);
   const heap = new Uint8Array(instance.exports.memory.buffer);
   heap.set(source, sp);
-  const res = fun(tp, count2, size, sp, source.length);
+  const res = fun(tp, count2, size2, sp, source.length);
   if (res === 0 && filter2) {
-    filter2(tp, count4, size);
+    filter2(tp, count4, size2);
   }
-  target.set(heap.subarray(tp, tp + count2 * size));
+  target.set(heap.subarray(tp, tp + count2 * size2));
   sbrk(tp - sbrk(0));
   if (res !== 0) {
     throw new Error("Malformed buffer data: ".concat(res));
@@ -90919,11 +91906,11 @@ class DracoParser {
       loaderAttribute.name = attributeName;
       const {
         value,
-        size
+        size: size2
       } = this._getAttributeValues(dracoGeometry, loaderAttribute);
       attributes[attributeName] = {
         value,
-        size,
+        size: size2,
         byteOffset: loaderAttribute.byte_offset,
         byteStride: loaderAttribute.byte_stride,
         normalized: loaderAttribute.normalized
@@ -91192,36 +92179,36 @@ function getGLTFAccessors(attributes) {
 function getGLTFAccessor(attribute) {
   const {
     buffer,
-    size,
+    size: size2,
     count: count2
   } = getAccessorData(attribute);
   const glTFAccessor = {
     value: buffer,
-    size,
+    size: size2,
     byteOffset: 0,
     count: count2,
-    type: getAccessorTypeFromSize(size),
+    type: getAccessorTypeFromSize(size2),
     componentType: getComponentTypeFromArray(buffer)
   };
   return glTFAccessor;
 }
 function getAccessorData(attribute) {
   let buffer = attribute;
-  let size = 1;
+  let size2 = 1;
   let count2 = 0;
   if (attribute && attribute.value) {
     buffer = attribute.value;
-    size = attribute.size || 1;
+    size2 = attribute.size || 1;
   }
   if (buffer) {
     if (!ArrayBuffer.isView(buffer)) {
       buffer = toTypedArray(buffer, Float32Array);
     }
-    count2 = buffer.length / size;
+    count2 = buffer.length / size2;
   }
   return {
     buffer,
-    size,
+    size: size2,
     count: count2
   };
 }
@@ -93464,8 +94451,8 @@ function getObbSize(halfAxes) {
   const axeY = halfAxes.getColumn(1);
   const axeZ = halfAxes.getColumn(2);
   const farthestVertex = scratchVector$1.add(axeY).add(axeZ);
-  const size = farthestVertex.len();
-  return size;
+  const size2 = farthestVertex.len();
+  return size2;
 }
 const TILE_CONTENT_STATE = {
   UNLOADED: 0,
@@ -95466,15 +96453,15 @@ function createTypedArrayFromAccessor(tile3DAccessor, buffer, byteOffset, length
   } = tile3DAccessor;
   assert$c(tile3DAccessor.componentType);
   const type = typeof componentType === "string" ? GLType.fromName(componentType) : componentType;
-  const size = COMPONENTS_PER_ATTRIBUTE[tile3DAccessor.type];
+  const size2 = COMPONENTS_PER_ATTRIBUTE[tile3DAccessor.type];
   const unpacker = UNPACKER[tile3DAccessor.type];
   const packer = PACKER[tile3DAccessor.type];
   byteOffset += tile3DAccessor.byteOffset;
-  const values2 = GLType.createTypedArray(type, buffer, byteOffset, size * length2);
+  const values2 = GLType.createTypedArray(type, buffer, byteOffset, size2 * length2);
   return {
     values: values2,
     type,
-    size,
+    size: size2,
     unpacker,
     packer
   };
@@ -113864,8 +114851,8 @@ function fitExtent(projection2, extent2, object2) {
   if (clip2 != null) projection2.clipExtent(clip2);
   return projection2.scale(k * 150).translate([x, y]);
 }
-function fitSize(projection2, size, object2) {
-  return fitExtent(projection2, [[0, 0], size], object2);
+function fitSize(projection2, size2, object2) {
+  return fitExtent(projection2, [[0, 0], size2], object2);
 }
 var maxDepth = 16, cosMinDistance = cos(30 * radians);
 function resample(project2, delta2) {
@@ -113991,8 +114978,8 @@ function projectionMutator(projectAt) {
   projection2.fitExtent = function(extent2, object2) {
     return fitExtent(projection2, extent2, object2);
   };
-  projection2.fitSize = function(size, object2) {
-    return fitSize(projection2, size, object2);
+  projection2.fitSize = function(size2, object2) {
+    return fitSize(projection2, size2, object2);
   };
   function recenter() {
     projectRotate = compose(rotate2 = rotateRadians(deltaLambda, deltaPhi, deltaGamma), project2);
@@ -114113,8 +115100,8 @@ function albersUsa() {
   albersUsa2.fitExtent = function(extent2, object2) {
     return fitExtent(albersUsa2, extent2, object2);
   };
-  albersUsa2.fitSize = function(size, object2) {
-    return fitSize(albersUsa2, size, object2);
+  albersUsa2.fitSize = function(size2, object2) {
+    return fitSize(albersUsa2, size2, object2);
   };
   function reset() {
     cache2 = cacheStream = null;
@@ -114277,8 +115264,8 @@ function identity() {
     fitExtent: function(extent2, object2) {
       return fitExtent(projection2, extent2, object2);
     },
-    fitSize: function(size, object2) {
-      return fitSize(projection2, size, object2);
+    fitSize: function(size2, object2) {
+      return fitSize(projection2, size2, object2);
     }
   };
 }
@@ -114896,18 +115883,18 @@ function requirePolygonClipping_umd() {
             if (presort === void 0) {
               presort = false;
             }
-            var size = keys2.length;
+            var size2 = keys2.length;
             var comparator2 = this._comparator;
-            if (presort) sort(keys2, values2, 0, size - 1, comparator2);
+            if (presort) sort(keys2, values2, 0, size2 - 1, comparator2);
             if (this._root === null) {
-              this._root = loadRecursive(keys2, values2, 0, size);
-              this._size = size;
+              this._root = loadRecursive(keys2, values2, 0, size2);
+              this._size = size2;
             } else {
               var mergedList = mergeLists(this.toList(), createList(keys2, values2), comparator2);
-              size = this._size + size;
+              size2 = this._size + size2;
               this._root = sortedListToBST({
                 head: mergedList
-              }, 0, size);
+              }, 0, size2);
             }
             return this;
           };
@@ -114957,9 +115944,9 @@ function requirePolygonClipping_umd() {
         }()
       );
       function loadRecursive(keys2, values2, start, end) {
-        var size = end - start;
-        if (size > 0) {
-          var middle = start + Math.floor(size / 2);
+        var size2 = end - start;
+        if (size2 > 0) {
+          var middle = start + Math.floor(size2 / 2);
           var key = keys2[middle];
           var data = values2[middle];
           var node2 = new Node2(key, data);
@@ -114999,9 +115986,9 @@ function requirePolygonClipping_umd() {
         return head.next;
       }
       function sortedListToBST(list, start, end) {
-        var size = end - start;
-        if (size > 0) {
-          var middle = start + Math.floor(size / 2);
+        var size2 = end - start;
+        if (size2 > 0) {
+          var middle = start + Math.floor(size2 / 2);
           var left = sortedListToBST(list, start, middle);
           var root2 = list.head;
           root2.left = left;
@@ -126063,19 +127050,19 @@ function requireExtrudeMode() {
         if (editHandle) {
           var featureIndex = editHandle.properties.featureIndex;
           var positionIndexes = editHandle.properties.positionIndexes;
-          var size = this.coordinatesSize(positionIndexes, featureIndex, props.data);
-          positionIndexes = this.isPointAdded ? this.nextPositionIndexes(positionIndexes, size) : positionIndexes;
-          var p1 = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size), featureIndex, props.data);
+          var size2 = this.coordinatesSize(positionIndexes, featureIndex, props.data);
+          positionIndexes = this.isPointAdded ? this.nextPositionIndexes(positionIndexes, size2) : positionIndexes;
+          var p1 = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size2), featureIndex, props.data);
           var p2 = this.getPointForPositionIndexes(positionIndexes, featureIndex, props.data);
           if (p1 && p2) {
             var _generatePointsParall = (0, _utils.generatePointsParallelToLinePoints)(p1, p2, event.mapCoords), _generatePointsParall2 = _slicedToArray(_generatePointsParall, 2), p3 = _generatePointsParall2[0], p4 = _generatePointsParall2[1];
-            var updatedData = new _immutableFeatureCollection.ImmutableFeatureCollection(props.data).replacePosition(featureIndex, this.prevPositionIndexes(positionIndexes, size), p4).replacePosition(featureIndex, positionIndexes, p3).getObject();
+            var updatedData = new _immutableFeatureCollection.ImmutableFeatureCollection(props.data).replacePosition(featureIndex, this.prevPositionIndexes(positionIndexes, size2), p4).replacePosition(featureIndex, positionIndexes, p3).getObject();
             props.onEdit({
               updatedData,
               editType: "extruding",
               editContext: {
                 featureIndexes: [featureIndex],
-                positionIndexes: this.nextPositionIndexes(positionIndexes, size),
+                positionIndexes: this.nextPositionIndexes(positionIndexes, size2),
                 position: p3
               }
             });
@@ -126090,15 +127077,15 @@ function requireExtrudeMode() {
         var editHandle = (0, _utils.getPickedIntermediateEditHandle)(event.picks);
         if (selectedFeatureIndexes.length && editHandle) {
           var _editHandle$propertie = editHandle.properties, positionIndexes = _editHandle$propertie.positionIndexes, featureIndex = _editHandle$propertie.featureIndex;
-          var size = this.coordinatesSize(positionIndexes, featureIndex, props.data);
-          var p1 = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size), featureIndex, props.data);
+          var size2 = this.coordinatesSize(positionIndexes, featureIndex, props.data);
+          var p1 = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size2), featureIndex, props.data);
           var p2 = this.getPointForPositionIndexes(positionIndexes, featureIndex, props.data);
           if (p1 && p2) {
             var updatedData = new _immutableFeatureCollection.ImmutableFeatureCollection(props.data);
-            if (!this.isOrthogonal(positionIndexes, featureIndex, size, props.data)) {
+            if (!this.isOrthogonal(positionIndexes, featureIndex, size2, props.data)) {
               updatedData = updatedData.addPosition(featureIndex, positionIndexes, p2);
             }
-            if (!this.isOrthogonal(this.prevPositionIndexes(positionIndexes, size), featureIndex, size, props.data)) {
+            if (!this.isOrthogonal(this.prevPositionIndexes(positionIndexes, size2), featureIndex, size2, props.data)) {
               updatedData = updatedData.addPosition(featureIndex, positionIndexes, p1);
               this.isPointAdded = true;
             }
@@ -126122,13 +127109,13 @@ function requireExtrudeMode() {
         if (selectedFeatureIndexes.length && editHandle) {
           var featureIndex = editHandle.properties.featureIndex;
           var positionIndexes = editHandle.properties.positionIndexes;
-          var size = this.coordinatesSize(positionIndexes, featureIndex, props.data);
-          positionIndexes = this.isPointAdded ? this.nextPositionIndexes(positionIndexes, size) : positionIndexes;
-          var p1 = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size), featureIndex, props.data);
+          var size2 = this.coordinatesSize(positionIndexes, featureIndex, props.data);
+          positionIndexes = this.isPointAdded ? this.nextPositionIndexes(positionIndexes, size2) : positionIndexes;
+          var p1 = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size2), featureIndex, props.data);
           var p2 = this.getPointForPositionIndexes(positionIndexes, featureIndex, props.data);
           if (p1 && p2) {
             var _generatePointsParall3 = (0, _utils.generatePointsParallelToLinePoints)(p1, p2, event.mapCoords), _generatePointsParall4 = _slicedToArray(_generatePointsParall3, 2), p3 = _generatePointsParall4[0], p4 = _generatePointsParall4[1];
-            var updatedData = new _immutableFeatureCollection.ImmutableFeatureCollection(props.data).replacePosition(featureIndex, this.prevPositionIndexes(positionIndexes, size), p4).replacePosition(featureIndex, positionIndexes, p3).getObject();
+            var updatedData = new _immutableFeatureCollection.ImmutableFeatureCollection(props.data).replacePosition(featureIndex, this.prevPositionIndexes(positionIndexes, size2), p4).replacePosition(featureIndex, positionIndexes, p3).getObject();
             props.onEdit({
               updatedData,
               editType: "extruded",
@@ -126146,23 +127133,23 @@ function requireExtrudeMode() {
       key: "coordinatesSize",
       value: function coordinatesSize(positionIndexes, featureIndex, _ref) {
         var features = _ref.features;
-        var size = 0;
+        var size2 = 0;
         if (Array.isArray(positionIndexes)) {
           var feature2 = features[featureIndex];
           var coordinates2 = feature2.geometry.coordinates;
           if (positionIndexes.length === 3) {
             var _positionIndexes = _slicedToArray(positionIndexes, 2), a2 = _positionIndexes[0], b = _positionIndexes[1];
             if (coordinates2.length && coordinates2[a2].length) {
-              size = coordinates2[a2][b].length;
+              size2 = coordinates2[a2][b].length;
             }
           } else {
             var _positionIndexes2 = _slicedToArray(positionIndexes, 1), _b2 = _positionIndexes2[0];
             if (coordinates2.length && coordinates2[_b2].length) {
-              size = coordinates2[_b2].length;
+              size2 = coordinates2[_b2].length;
             }
           }
         }
-        return size;
+        return size2;
       }
     }, {
       key: "getBearing",
@@ -126175,15 +127162,15 @@ function requireExtrudeMode() {
       }
     }, {
       key: "isOrthogonal",
-      value: function isOrthogonal(positionIndexes, featureIndex, size, features) {
+      value: function isOrthogonal(positionIndexes, featureIndex, size2, features) {
         if (!Array.isArray(positionIndexes)) {
           return false;
         }
-        if (positionIndexes[positionIndexes.length - 1] === size - 1) {
+        if (positionIndexes[positionIndexes.length - 1] === size2 - 1) {
           positionIndexes[positionIndexes.length - 1] = 0;
         }
-        var prevPoint = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size), featureIndex, features);
-        var nextPoint = this.getPointForPositionIndexes(this.nextPositionIndexes(positionIndexes, size), featureIndex, features);
+        var prevPoint = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size2), featureIndex, features);
+        var nextPoint = this.getPointForPositionIndexes(this.nextPositionIndexes(positionIndexes, size2), featureIndex, features);
         var currentPoint = this.getPointForPositionIndexes(positionIndexes, featureIndex, features);
         var prevAngle = this.getBearing(currentPoint, prevPoint);
         var nextAngle = this.getBearing(currentPoint, nextPoint);
@@ -126191,25 +127178,25 @@ function requireExtrudeMode() {
       }
     }, {
       key: "nextPositionIndexes",
-      value: function nextPositionIndexes(positionIndexes, size) {
+      value: function nextPositionIndexes(positionIndexes, size2) {
         if (!Array.isArray(positionIndexes)) {
           return [];
         }
         var next2 = _toConsumableArray(positionIndexes);
         if (next2.length) {
-          next2[next2.length - 1] = next2[next2.length - 1] === size - 1 ? 0 : next2[next2.length - 1] + 1;
+          next2[next2.length - 1] = next2[next2.length - 1] === size2 - 1 ? 0 : next2[next2.length - 1] + 1;
         }
         return next2;
       }
     }, {
       key: "prevPositionIndexes",
-      value: function prevPositionIndexes(positionIndexes, size) {
+      value: function prevPositionIndexes(positionIndexes, size2) {
         if (!Array.isArray(positionIndexes)) {
           return [];
         }
         var prev2 = _toConsumableArray(positionIndexes);
         if (prev2.length) {
-          prev2[prev2.length - 1] = prev2[prev2.length - 1] === 0 ? size - 2 : prev2[prev2.length - 1] - 1;
+          prev2[prev2.length - 1] = prev2[prev2.length - 1] === 0 ? size2 - 2 : prev2[prev2.length - 1] - 1;
         }
         return prev2;
       }
@@ -138179,22 +139166,22 @@ function addDecoder(cases, importFn) {
   }
   cases.forEach((c) => registry$1.set(c, importFn));
 }
-addDecoder([void 0, 1], () => import("./raw-CuoVZYgh.js").then((m) => m.default));
-addDecoder(5, () => import("./lzw-B49kANWk.js").then((m) => m.default));
+addDecoder([void 0, 1], () => import("./raw-M2AeXGn-.js").then((m) => m.default));
+addDecoder(5, () => import("./lzw-SmfMfK-N.js").then((m) => m.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-ej4QpQD2.js").then((m) => m.default));
-addDecoder([8, 32946], () => import("./deflate-DoBsfd5X.js").then((m) => m.default));
-addDecoder(32773, () => import("./packbits-Chm1I75k.js").then((m) => m.default));
+addDecoder(7, () => import("./jpeg-MuaEoA29.js").then((m) => m.default));
+addDecoder([8, 32946], () => import("./deflate-CafSYkE8.js").then((m) => m.default));
+addDecoder(32773, () => import("./packbits-DM8_km8s.js").then((m) => m.default));
 addDecoder(
   34887,
-  () => import("./lerc-DmcLtqzg.js").then(async (m) => {
+  () => import("./lerc-Crl3Us1z.js").then(async (m) => {
     await m.zstd.init();
     return m;
   }).then((m) => m.default)
 );
-addDecoder(50001, () => import("./webimage-BTaPGzt_.js").then((m) => m.default));
+addDecoder(50001, () => import("./webimage-BH-xh1eM.js").then((m) => m.default));
 function decodeRowAcc(row, stride) {
   let length2 = row.length - stride;
   let offset2 = 0;
@@ -139424,10 +140411,10 @@ const putShortMSB = (s2, b) => {
   s2.pending_buf[s2.pending++] = b >>> 8 & 255;
   s2.pending_buf[s2.pending++] = b & 255;
 };
-const read_buf = (strm, buf, start, size) => {
+const read_buf = (strm, buf, start, size2) => {
   let len2 = strm.avail_in;
-  if (len2 > size) {
-    len2 = size;
+  if (len2 > size2) {
+    len2 = size2;
   }
   if (len2 === 0) {
     return 0;
@@ -145950,9 +146937,9 @@ const SI_PREFIXES = [
   { symbol: "z", exponent: -21 },
   { symbol: "y", exponent: -24 }
 ];
-function sizeToMeters(size, unit2) {
+function sizeToMeters(size2, unit2) {
   if (!unit2 || unit2 === "m") {
-    return size;
+    return size2;
   }
   if (unit2.length > 1) {
     let unitPrefix = unit2.substring(0, unit2.length - 1);
@@ -145961,7 +146948,7 @@ function sizeToMeters(size, unit2) {
     }
     const unitObj = SI_PREFIXES.find((p) => p.symbol === unitPrefix);
     if (unitObj) {
-      return size * 10 ** unitObj.exponent;
+      return size2 * 10 ** unitObj.exponent;
     }
   }
   throw new Error("Received unknown unit");
@@ -146865,7 +147852,7 @@ const defaultProps$2$1 = {
 };
 const ScaleBarLayer = class extends CompositeLayer {
   renderLayers() {
-    const { id, unit: unit2, size, position: position2, viewState, length: length2, snap } = this.props;
+    const { id, unit: unit2, size: size2, position: position2, viewState, length: length2, snap } = this.props;
     const boundingBox = makeBoundingBox(viewState);
     const { zoom } = viewState;
     const viewLength = boundingBox[2][0] - boundingBox[0][0];
@@ -146875,10 +147862,10 @@ const ScaleBarLayer = class extends CompositeLayer {
       (boundingBox[2][1] - boundingBox[0][1]) * 7e-3
     );
     let adjustedBarLength = barLength;
-    let displayNumber = (barLength * size).toPrecision(5);
+    let displayNumber = (barLength * size2).toPrecision(5);
     let displayUnit = unit2;
     if (snap) {
-      const meterSize = sizeToMeters(size, unit2);
+      const meterSize = sizeToMeters(size2, unit2);
       const numUnits = barLength * meterSize;
       const [snappedOrigUnits, snappedNewUnits, snappedUnitPrefix] = snapValue(numUnits);
       adjustedBarLength = snappedOrigUnits / meterSize;
@@ -151943,7 +152930,7 @@ const Heatmap = forwardRef((props, deckRef) => {
     }
     const newCellOrdering = !cellColors || cellColors.size === 0 ? obsIndex : Array.from(cellColors.keys());
     const oldCellOrdering = transpose2 ? axisTopLabels : axisLeftLabels;
-    if (!isEqual$1(oldCellOrdering, newCellOrdering)) {
+    if (!isEqual$2(oldCellOrdering, newCellOrdering)) {
       if (transpose2) {
         setAxisTopLabels(newCellOrdering);
       } else {