@deck.gl/carto 9.2.0-alpha.3 → 9.2.0-beta.2

package/dist/dist.dev.js

@@ -394,6 +394,13 @@ var __exports__ = (() => {
     }
   });
 
+  // external-global-plugin:h3-js
+  var require_h3_js = __commonJS({
+    "external-global-plugin:h3-js"(exports, module) {
+      module.exports = globalThis.h3 || {};
+    }
+  });
+
   // ../../node_modules/pako/lib/utils/common.js
   var require_common = __commonJS({
     "../../node_modules/pako/lib/utils/common.js"(exports) {
@@ -5342,13 +5349,6 @@ var __exports__ = (() => {
     }
   });
 
-  // external-global-plugin:h3-js
-  var require_h3_js = __commonJS({
-    "external-global-plugin:h3-js"(exports, module) {
-      module.exports = globalThis.h3 || {};
-    }
-  });
-
   // ../../node_modules/earcut/src/earcut.js
   var require_earcut = __commonJS({
     "../../node_modules/earcut/src/earcut.js"(exports, module) {
@@ -5858,7 +5858,7 @@ var __exports__ = (() => {
 
   // src/layers/cluster-tile-layer.ts
   var import_layers = __toESM(require_layers(), 1);
-  var import_geo_layers2 = __toESM(require_geo_layers(), 1);
+  var import_geo_layers3 = __toESM(require_geo_layers(), 1);
   var import_core5 = __toESM(require_core(), 1);
 
   // ../../node_modules/@loaders.gl/gis/dist/lib/binary-features/binary-to-geojson.js
@@ -6105,6 +6105,7 @@ var __exports__ = (() => {
   }
 
   // src/layers/cluster-utils.ts
+  var import_h3_js = __toESM(require_h3_js(), 1);
   var import_core2 = __toESM(require_core2(), 1);
 
   // src/utils.ts
@@ -6189,7 +6190,7 @@ var __exports__ = (() => {
   }
 
   // src/layers/cluster-utils.ts
-  function aggregateTile(tile, tileAggregationCache, aggregationLevels, properties = [], getPosition, getWeight) {
+  function aggregateTile(tile, tileAggregationCache, aggregationLevels, properties = [], getPosition, getWeight, scheme = "quadbin") {
     if (!tile.content)
       return false;
     if (!tile.userData)
@@ -6206,9 +6207,14 @@ var __exports__ = (() => {
       let id5 = cell.id;
       const position = typeof getPosition === "function" ? getPosition(cell, {}) : getPosition;
       for (let i = 0; i < aggregationLevels - 1; i++) {
-        id5 = cellToParent(id5);
+        if (scheme === "h3") {
+          const currentResolution = (0, import_h3_js.getResolution)(id5);
+          id5 = (0, import_h3_js.cellToParent)(id5, Math.max(0, currentResolution - 1));
+        } else {
+          id5 = cellToParent(id5);
+        }
       }
-      const parentId = Number(id5);
+      const parentId = String(id5);
       if (!(parentId in out)) {
         out[parentId] = { id: id5, count: 0, position: [0, 0] };
         for (const { name, aggregation } of properties) {
@@ -6309,6 +6315,118 @@ var __exports__ = (() => {
     }
   };
 
+  // src/layers/h3-tileset-2d.ts
+  var import_geo_layers2 = __toESM(require_geo_layers(), 1);
+  var import_h3_js2 = __toESM(require_h3_js(), 1);
+  var MAX_LATITUDE2 = 85.051128;
+  function padBoundingBox({ west, north, east, south }, resolution, scale = 1) {
+    const corners = [
+      [north, east],
+      [south, east],
+      [south, west],
+      [north, west]
+    ];
+    const cornerCells = corners.map((c) => (0, import_h3_js2.latLngToCell)(c[0], c[1], resolution));
+    const cornerEdgeLengths = cornerCells.map(
+      (c) => Math.max(...(0, import_h3_js2.originToDirectedEdges)(c).map((e) => (0, import_h3_js2.edgeLength)(e, import_h3_js2.UNITS.rads))) * 180 / Math.PI
+    );
+    const bufferLat = Math.max(...cornerEdgeLengths) * scale;
+    const bufferLon = Math.min(180, bufferLat / Math.cos((north + south) / 2 * Math.PI / 180));
+    return {
+      north: Math.min(north + bufferLat, MAX_LATITUDE2),
+      east: east + bufferLon,
+      south: Math.max(south - bufferLat, -MAX_LATITUDE2),
+      west: west - bufferLon
+    };
+  }
+  function getHexagonsInBoundingBox({ west, north, east, south }, resolution) {
+    const longitudeSpan = Math.abs(east - west);
+    if (longitudeSpan > 180) {
+      const nSegments = Math.ceil(longitudeSpan / 180);
+      let h3Indices = [];
+      for (let s = 0; s < nSegments; s++) {
+        const segmentWest = west + s * 180;
+        const segmentEast = Math.min(segmentWest + 179.9999999, east);
+        h3Indices = h3Indices.concat(
+          getHexagonsInBoundingBox({ west: segmentWest, north, east: segmentEast, south }, resolution)
+        );
+      }
+      return [...new Set(h3Indices)];
+    }
+    const polygon2 = [
+      [north, east],
+      [south, east],
+      [south, west],
+      [north, west],
+      [north, east]
+    ];
+    return (0, import_h3_js2.polygonToCells)(polygon2, resolution);
+  }
+  function tileToBoundingBox(index2) {
+    const coordinates = (0, import_h3_js2.cellToBoundary)(index2);
+    const latitudes = coordinates.map((c) => c[0]);
+    const longitudes = coordinates.map((c) => c[1]);
+    const west = Math.min(...longitudes);
+    const south = Math.min(...latitudes);
+    const east = Math.max(...longitudes);
+    const north = Math.max(...latitudes);
+    const bbox2 = { west, south, east, north };
+    return padBoundingBox(bbox2, (0, import_h3_js2.getResolution)(index2), 0.12);
+  }
+  var BIAS = 2;
+  function getHexagonResolution(viewport, tileSize) {
+    const zoomOffset = Math.log2(tileSize / 512);
+    const hexagonScaleFactor = 2 / 3 * (viewport.zoom - zoomOffset);
+    const latitudeScaleFactor = Math.log(1 / Math.cos(Math.PI * viewport.latitude / 180));
+    return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
+  }
+  var H3Tileset2D = class extends import_geo_layers2._Tileset2D {
+    /**
+     * Returns all tile indices in the current viewport. If the current zoom level is smaller
+     * than minZoom, return an empty array. If the current zoom level is greater than maxZoom,
+     * return tiles that are on maxZoom.
+     */
+    // @ts-expect-error Tileset2D should be generic over TileIndex
+    getTileIndices({ viewport, minZoom, maxZoom }) {
+      if (viewport.latitude === void 0)
+        return [];
+      const [west, south, east, north] = viewport.getBounds();
+      const { tileSize } = this.opts;
+      let z = getHexagonResolution(viewport, tileSize);
+      let indices;
+      if (typeof minZoom === "number" && Number.isFinite(minZoom) && z < minZoom) {
+        return [];
+      }
+      if (typeof maxZoom === "number" && Number.isFinite(maxZoom) && z > maxZoom) {
+        z = maxZoom;
+        const center = (0, import_h3_js2.latLngToCell)(viewport.latitude, viewport.longitude, maxZoom);
+        indices = (0, import_h3_js2.gridDisk)(center, 1);
+      } else {
+        const paddedBounds = padBoundingBox({ west, north, east, south }, z);
+        indices = getHexagonsInBoundingBox(paddedBounds, z);
+      }
+      return indices.map((i) => ({ i }));
+    }
+    // @ts-expect-error Tileset2D should be generic over TileIndex
+    getTileId({ i }) {
+      return i;
+    }
+    // @ts-expect-error Tileset2D should be generic over TileIndex
+    getTileMetadata({ i }) {
+      return { bbox: tileToBoundingBox(i) };
+    }
+    // @ts-expect-error Tileset2D should be generic over TileIndex
+    getTileZoom({ i }) {
+      return (0, import_h3_js2.getResolution)(i);
+    }
+    // @ts-expect-error Tileset2D should be generic over TileIndex
+    getParentIndex(index2) {
+      const resolution = (0, import_h3_js2.getResolution)(index2.i);
+      const i = (0, import_h3_js2.cellToParent)(index2.i, resolution - 1);
+      return { i };
+    }
+  };
+
   // src/layers/quadbin-utils.ts
   var TILE_SIZE2 = 512;
   function quadbinToOffset(quadbin) {
@@ -6330,6 +6448,9 @@ var __exports__ = (() => {
     return [e, n, e, s, w, s, w, n, e, n];
   }
 
+  // src/layers/cluster-tile-layer.ts
+  var import_h3_js3 = __toESM(require_h3_js(), 1);
+
   // node_modules/@loaders.gl/compression/node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/globals.js
   var globals = {
     self: typeof self !== "undefined" && self,
@@ -6987,40 +7108,62 @@ var __exports__ = (() => {
 
   // src/layers/cluster-tile-layer.ts
   (0, import_core5.registerLoaders)([carto_spatial_tile_loader_default]);
+  function getScheme(tilesetClass) {
+    if (tilesetClass === H3Tileset2D)
+      return "h3";
+    if (tilesetClass === QuadbinTileset2D)
+      return "quadbin";
+    throw new Error("Invalid tileset class");
+  }
   var defaultProps = {
     data: TilejsonPropType,
     clusterLevel: { type: "number", value: 5, min: 1 },
     getPosition: {
       type: "accessor",
-      value: ({ id: id5 }) => getQuadbinPolygon(id5, 0.5).slice(2, 4)
+      value: ({ id: id5 }) => {
+        if (typeof id5 === "string") {
+          const [lat, lng] = (0, import_h3_js3.cellToLatLng)(id5);
+          return [lng, lat];
+        }
+        return getQuadbinPolygon(id5, 0.5).slice(2, 4);
+      }
     },
     getWeight: { type: "accessor", value: 1 },
     refinementStrategy: "no-overlap",
     tileSize: DEFAULT_TILE_SIZE
   };
-  var ClusterGeoJsonLayer = class extends import_geo_layers2.TileLayer {
+  var ClusterGeoJsonLayer = class extends import_geo_layers3.TileLayer {
     initializeState() {
       super.initializeState();
       this.state.aggregationCache = /* @__PURE__ */ new WeakMap();
+      this.state.scheme = getScheme(this.props.TilesetClass);
+    }
+    updateState(opts) {
+      const { props } = opts;
+      const scheme = getScheme(props.TilesetClass);
+      if (this.state.scheme !== scheme) {
+        this.setState({ scheme, tileset: null });
+        this.state.aggregationCache = /* @__PURE__ */ new WeakMap();
+      }
+      super.updateState(opts);
     }
     // eslint-disable-next-line max-statements
     renderLayers() {
       const visibleTiles = this.state.tileset?.tiles.filter((tile) => {
         return tile.isLoaded && tile.content && this.state.tileset.isTileVisible(tile);
       });
-      if (!visibleTiles?.length) {
+      if (!visibleTiles?.length || !this.state.tileset) {
         return null;
       }
       visibleTiles.sort((a, b) => b.zoom - a.zoom);
-      const { zoom } = this.context.viewport;
-      const { clusterLevel, getPosition, getWeight } = this.props;
-      const { aggregationCache } = this.state;
+      const { getPosition, getWeight } = this.props;
+      const { aggregationCache, scheme } = this.state;
+      const isH3 = scheme === "h3";
       const properties = extractAggregationProperties(visibleTiles[0]);
       const data = [];
       let needsUpdate = false;
+      const aggregationLevels = this._getAggregationLevels(visibleTiles);
       for (const tile of visibleTiles) {
-        const overZoom = Math.round(zoom - tile.zoom);
-        const aggregationLevels = Math.round(clusterLevel) - overZoom;
         let tileAggregationCache = aggregationCache.get(tile.content);
         if (!tileAggregationCache) {
           tileAggregationCache = /* @__PURE__ */ new Map();
@@ -7032,7 +7175,8 @@ var __exports__ = (() => {
           aggregationLevels,
           properties,
           getPosition,
-          getWeight
+          getWeight,
+          isH3 ? "h3" : "quadbin"
         );
         needsUpdate ||= didAggregate;
         data.push(...tileAggregationCache.get(aggregationLevels));
@@ -7077,15 +7221,35 @@ var __exports__ = (() => {
     filterSubLayer() {
       return true;
     }
+    _getAggregationLevels(visibleTiles) {
+      const isH3 = this.state.scheme === "h3";
+      const firstTile = visibleTiles[0];
+      let tileResolution;
+      let viewportResolution;
+      if (isH3) {
+        tileResolution = (0, import_h3_js3.getResolution)(firstTile.id);
+        viewportResolution = getHexagonResolution(
+          this.context.viewport,
+          this.state.tileset.opts.tileSize
+        );
+      } else {
+        tileResolution = firstTile.zoom;
+        viewportResolution = this.context.viewport.zoom;
+      }
+      const resolutionDiff = Math.round(viewportResolution - tileResolution);
+      const aggregationLevels = Math.round(this.props.clusterLevel) - resolutionDiff;
+      return aggregationLevels;
+    }
   };
   ClusterGeoJsonLayer.layerName = "ClusterGeoJsonLayer";
   ClusterGeoJsonLayer.defaultProps = defaultProps;
   var ClusterTileLayer = class extends import_core6.CompositeLayer {
     getLoadOptions() {
       const tileJSON = this.props.data;
+      const scheme = tileJSON && "scheme" in tileJSON ? tileJSON.scheme : "quadbin";
       return mergeLoadOptions(super.getLoadOptions(), {
         fetch: { headers: { Authorization: `Bearer ${tileJSON.accessToken}` } },
-        cartoSpatialTile: { scheme: "quadbin" }
+        cartoSpatialTile: { scheme }
       });
     }
     renderLayers() {
@@ -7093,13 +7257,15 @@ var __exports__ = (() => {
       if (!tileJSON)
         return null;
       const { tiles: data, maxresolution: maxZoom } = tileJSON;
+      const isH3 = tileJSON && "scheme" in tileJSON && tileJSON.scheme === "h3";
+      const TilesetClass = isH3 ? H3Tileset2D : QuadbinTileset2D;
       return [
         // @ts-ignore
         new ClusterGeoJsonLayer(this.props, {
           id: `cluster-geojson-layer-${this.props.id}`,
           data,
           // TODO: Tileset2D should be generic over TileIndex type
-          TilesetClass: QuadbinTileset2D,
+          TilesetClass,
           maxZoom,
           loadOptions: this.getLoadOptions()
         })
@@ -7113,118 +7279,6 @@ var __exports__ = (() => {
   var import_core8 = __toESM(require_core2(), 1);
   var import_geo_layers5 = __toESM(require_geo_layers(), 1);
 
-  // src/layers/h3-tileset-2d.ts
-  var import_geo_layers3 = __toESM(require_geo_layers(), 1);
-  var import_h3_js = __toESM(require_h3_js(), 1);
-  var MAX_LATITUDE2 = 85.051128;
-  function padBoundingBox({ west, north, east, south }, resolution, scale = 1) {
-    const corners = [
-      [north, east],
-      [south, east],
-      [south, west],
-      [north, west]
-    ];
-    const cornerCells = corners.map((c) => (0, import_h3_js.latLngToCell)(c[0], c[1], resolution));
-    const cornerEdgeLengths = cornerCells.map(
-      (c) => Math.max(...(0, import_h3_js.originToDirectedEdges)(c).map((e) => (0, import_h3_js.edgeLength)(e, import_h3_js.UNITS.rads))) * 180 / Math.PI
-    );
-    const bufferLat = Math.max(...cornerEdgeLengths) * scale;
-    const bufferLon = Math.min(180, bufferLat / Math.cos((north + south) / 2 * Math.PI / 180));
-    return {
-      north: Math.min(north + bufferLat, MAX_LATITUDE2),
-      east: east + bufferLon,
-      south: Math.max(south - bufferLat, -MAX_LATITUDE2),
-      west: west - bufferLon
-    };
-  }
-  function getHexagonsInBoundingBox({ west, north, east, south }, resolution) {
-    const longitudeSpan = Math.abs(east - west);
-    if (longitudeSpan > 180) {
-      const nSegments = Math.ceil(longitudeSpan / 180);
-      let h3Indices = [];
-      for (let s = 0; s < nSegments; s++) {
-        const segmentWest = west + s * 180;
-        const segmentEast = Math.min(segmentWest + 179.9999999, east);
-        h3Indices = h3Indices.concat(
-          getHexagonsInBoundingBox({ west: segmentWest, north, east: segmentEast, south }, resolution)
-        );
-      }
-      return [...new Set(h3Indices)];
-    }
-    const polygon2 = [
-      [north, east],
-      [south, east],
-      [south, west],
-      [north, west],
-      [north, east]
-    ];
-    return (0, import_h3_js.polygonToCells)(polygon2, resolution);
-  }
-  function tileToBoundingBox(index2) {
-    const coordinates = (0, import_h3_js.cellToBoundary)(index2);
-    const latitudes = coordinates.map((c) => c[0]);
-    const longitudes = coordinates.map((c) => c[1]);
-    const west = Math.min(...longitudes);
-    const south = Math.min(...latitudes);
-    const east = Math.max(...longitudes);
-    const north = Math.max(...latitudes);
-    const bbox2 = { west, south, east, north };
-    return padBoundingBox(bbox2, (0, import_h3_js.getResolution)(index2), 0.12);
-  }
-  var BIAS = 2;
-  function getHexagonResolution(viewport, tileSize) {
-    const zoomOffset = Math.log2(tileSize / 512);
-    const hexagonScaleFactor = 2 / 3 * (viewport.zoom - zoomOffset);
-    const latitudeScaleFactor = Math.log(1 / Math.cos(Math.PI * viewport.latitude / 180));
-    return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
-  }
-  var H3Tileset2D = class extends import_geo_layers3._Tileset2D {
-    /**
-     * Returns all tile indices in the current viewport. If the current zoom level is smaller
-     * than minZoom, return an empty array. If the current zoom level is greater than maxZoom,
-     * return tiles that are on maxZoom.
-     */
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getTileIndices({ viewport, minZoom, maxZoom }) {
-      if (viewport.latitude === void 0)
-        return [];
-      const [west, south, east, north] = viewport.getBounds();
-      const { tileSize } = this.opts;
-      let z = getHexagonResolution(viewport, tileSize);
-      let indices;
-      if (typeof minZoom === "number" && Number.isFinite(minZoom) && z < minZoom) {
-        return [];
-      }
-      if (typeof maxZoom === "number" && Number.isFinite(maxZoom) && z > maxZoom) {
-        z = maxZoom;
-        const center = (0, import_h3_js.latLngToCell)(viewport.latitude, viewport.longitude, maxZoom);
-        indices = (0, import_h3_js.gridDisk)(center, 1);
-      } else {
-        const paddedBounds = padBoundingBox({ west, north, east, south }, z);
-        indices = getHexagonsInBoundingBox(paddedBounds, z);
-      }
-      return indices.map((i) => ({ i }));
-    }
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getTileId({ i }) {
-      return i;
-    }
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getTileMetadata({ i }) {
-      return { bbox: tileToBoundingBox(i) };
-    }
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getTileZoom({ i }) {
-      return (0, import_h3_js.getResolution)(i);
-    }
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getParentIndex(index2) {
-      const resolution = (0, import_h3_js.getResolution)(index2.i);
-      const i = (0, import_h3_js.cellToParent)(index2.i, resolution - 1);
-      return { i };
-    }
-  };
-
   // src/layers/spatial-index-tile-layer.ts
   var import_core7 = __toESM(require_core(), 1);
   var import_geo_layers4 = __toESM(require_geo_layers(), 1);
@@ -7349,7 +7403,7 @@ var __exports__ = (() => {
   H3TileLayer.defaultProps = defaultProps3;
 
   // src/layers/heatmap-tile-layer.ts
-  var import_h3_js2 = __toESM(require_h3_js(), 1);
+  var import_h3_js4 = __toESM(require_h3_js(), 1);
   var import_core11 = __toESM(require_core2(), 1);
   var import_layers2 = __toESM(require_layers(), 1);
 
@@ -7713,8 +7767,8 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
     return Math.pow(4, cellResolution);
   }
   function unitDensityForH3Cell(cellId) {
-    const cellResolution = Number((0, import_h3_js2.getResolution)(cellId));
-    return (0, import_h3_js2.getNumCells)(cellResolution);
+    const cellResolution = Number((0, import_h3_js4.getResolution)(cellId));
+    return (0, import_h3_js4.getNumCells)(cellResolution);
   }
   function colorRangeToFlatArray(colorRange) {
     const flatArray = new Uint8Array(colorRange.length * 4);
@@ -9315,6 +9369,26 @@ void main(void) {
   }
   var B2 = [0x5555555555555555n, 0x3333333333333333n, 0x0f0f0f0f0f0f0f0fn, 0x00ff00ff00ff00ffn, 0x0000ffff0000ffffn, 0x00000000ffffffffn];
   var S2 = [0n, 1n, 2n, 4n, 8n, 16n];
+  var TILE_SIZE3 = 512;
+  function cellToOffset(quadbin) {
+    const {
+      x,
+      y,
+      z
+    } = cellToTile2(quadbin);
+    const scale = TILE_SIZE3 / (1 << z);
+    return [x * scale, TILE_SIZE3 - y * scale, scale];
+  }
+  function cellToWorldBounds(quadbin, coverage) {
+    const [xOffset, yOffset, scale] = cellToOffset(quadbin);
+    return [[xOffset, yOffset], [xOffset + coverage * scale, yOffset - coverage * scale]];
+  }
+  function getCellPolygon(quadbin, coverage = 1) {
+    const [topLeft, bottomRight] = cellToWorldBounds(quadbin, coverage);
+    const [w, n] = worldToLngLat(topLeft);
+    const [e, s] = worldToLngLat(bottomRight);
+    return [e, n, e, s, w, s, w, n, e, n];
+  }
   function tileToCell2(tile) {
     if (tile.z < 0 || tile.z > 26) {
       throw new Error("Wrong zoom");
@@ -9356,26 +9430,9 @@ void main(void) {
       y: Number(y)
     };
   }
-  function getResolution3(quadbin) {
+  function getResolution4(quadbin) {
     return quadbin >> 52n & 0x1fn;
   }
-  function cellToChildren(quadbin, resolution) {
-    if (resolution < 0 || resolution > 26 || resolution < getResolution3(quadbin)) {
-      throw new Error("Invalid resolution");
-    }
-    const zoomLevelMask = ~(0x1fn << 52n);
-    const blockRange = 1n << (resolution - (quadbin >> 52n & 0x1fn) << 1n);
-    const sqrtBlockRange = 1n << resolution - (quadbin >> 52n & 0x1fn);
-    const blockShift = 52n - (resolution << 1n);
-    const childBase = (quadbin & zoomLevelMask | resolution << 52n) & ~(blockRange - 1n << blockShift);
-    const children = [];
-    for (let blockRow = 0n; blockRow < sqrtBlockRange; blockRow++) {
-      for (let blockColumn = 0n; blockColumn < sqrtBlockRange; blockColumn++) {
-        children.push(childBase | blockRow * sqrtBlockRange + blockColumn << blockShift);
-      }
-    }
-    return children;
-  }
   function geometryToCells(geometry, resolution) {
     const zoom = Number(resolution);
     return tiles2(geometry, {
@@ -9387,9 +9444,962 @@ void main(void) {
       z
     }));
   }
-
+  function cellToBoundary2(cell) {
+    const bbox2 = getCellPolygon(cell);
+    const boundary = [[bbox2[0], bbox2[1]], [bbox2[2], bbox2[3]], [bbox2[4], bbox2[5]], [bbox2[6], bbox2[7]], [bbox2[0], bbox2[1]]];
+    return {
+      type: "Polygon",
+      coordinates: [boundary]
+    };
+  }
+
   // ../../node_modules/@carto/api-client/build/api-client.js
-  var import_h3_js3 = __toESM(require_h3_js(), 1);
+  var import_h3_js5 = __toESM(require_h3_js(), 1);
+  var import_h3_js6 = __toESM(require_h3_js(), 1);
+
+  // ../../node_modules/@carto/api-client/node_modules/jsep/dist/jsep.js
+  var Hooks = class {
+    /**
+     * @callback HookCallback
+     * @this {*|Jsep} this
+     * @param {Jsep} env
+     * @returns: void
+     */
+    /**
+     * Adds the given callback to the list of callbacks for the given hook.
+     *
+     * The callback will be invoked when the hook it is registered for is run.
+     *
+     * One callback function can be registered to multiple hooks and the same hook multiple times.
+     *
+     * @param {string|object} name The name of the hook, or an object of callbacks keyed by name
+     * @param {HookCallback|boolean} callback The callback function which is given environment variables.
+     * @param {?boolean} [first=false] Will add the hook to the top of the list (defaults to the bottom)
+     * @public
+     */
+    add(name, callback, first) {
+      if (typeof arguments[0] != "string") {
+        for (let name2 in arguments[0]) {
+          this.add(name2, arguments[0][name2], arguments[1]);
+        }
+      } else {
+        (Array.isArray(name) ? name : [name]).forEach(function(name2) {
+          this[name2] = this[name2] || [];
+          if (callback) {
+            this[name2][first ? "unshift" : "push"](callback);
+          }
+        }, this);
+      }
+    }
+    /**
+     * Runs a hook invoking all registered callbacks with the given environment variables.
+     *
+     * Callbacks will be invoked synchronously and in the order in which they were registered.
+     *
+     * @param {string} name The name of the hook.
+     * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+     * @public
+     */
+    run(name, env) {
+      this[name] = this[name] || [];
+      this[name].forEach(function(callback) {
+        callback.call(env && env.context ? env.context : env, env);
+      });
+    }
+  };
+  var Plugins = class {
+    constructor(jsep2) {
+      this.jsep = jsep2;
+      this.registered = {};
+    }
+    /**
+     * @callback PluginSetup
+     * @this {Jsep} jsep
+     * @returns: void
+     */
+    /**
+     * Adds the given plugin(s) to the registry
+     *
+     * @param {object} plugins
+     * @param {string} plugins.name The name of the plugin
+     * @param {PluginSetup} plugins.init The init function
+     * @public
+     */
+    register(...plugins) {
+      plugins.forEach((plugin) => {
+        if (typeof plugin !== "object" || !plugin.name || !plugin.init) {
+          throw new Error("Invalid JSEP plugin format");
+        }
+        if (this.registered[plugin.name]) {
+          return;
+        }
+        plugin.init(this.jsep);
+        this.registered[plugin.name] = plugin;
+      });
+    }
+  };
+  var Jsep = class {
+    /**
+     * @returns {string}
+     */
+    static get version() {
+      return "1.4.0";
+    }
+    /**
+     * @returns {string}
+     */
+    static toString() {
+      return "JavaScript Expression Parser (JSEP) v" + Jsep.version;
+    }
+    // ==================== CONFIG ================================
+    /**
+     * @method addUnaryOp
+     * @param {string} op_name The name of the unary op to add
+     * @returns {Jsep}
+     */
+    static addUnaryOp(op_name) {
+      Jsep.max_unop_len = Math.max(op_name.length, Jsep.max_unop_len);
+      Jsep.unary_ops[op_name] = 1;
+      return Jsep;
+    }
+    /**
+     * @method jsep.addBinaryOp
+     * @param {string} op_name The name of the binary op to add
+     * @param {number} precedence The precedence of the binary op (can be a float). Higher number = higher precedence
+     * @param {boolean} [isRightAssociative=false] whether operator is right-associative
+     * @returns {Jsep}
+     */
+    static addBinaryOp(op_name, precedence, isRightAssociative) {
+      Jsep.max_binop_len = Math.max(op_name.length, Jsep.max_binop_len);
+      Jsep.binary_ops[op_name] = precedence;
+      if (isRightAssociative) {
+        Jsep.right_associative.add(op_name);
+      } else {
+        Jsep.right_associative.delete(op_name);
+      }
+      return Jsep;
+    }
+    /**
+     * @method addIdentifierChar
+     * @param {string} char The additional character to treat as a valid part of an identifier
+     * @returns {Jsep}
+     */
+    static addIdentifierChar(char) {
+      Jsep.additional_identifier_chars.add(char);
+      return Jsep;
+    }
+    /**
+     * @method addLiteral
+     * @param {string} literal_name The name of the literal to add
+     * @param {*} literal_value The value of the literal
+     * @returns {Jsep}
+     */
+    static addLiteral(literal_name, literal_value) {
+      Jsep.literals[literal_name] = literal_value;
+      return Jsep;
+    }
+    /**
+     * @method removeUnaryOp
+     * @param {string} op_name The name of the unary op to remove
+     * @returns {Jsep}
+     */
+    static removeUnaryOp(op_name) {
+      delete Jsep.unary_ops[op_name];
+      if (op_name.length === Jsep.max_unop_len) {
+        Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);
+      }
+      return Jsep;
+    }
+    /**
+     * @method removeAllUnaryOps
+     * @returns {Jsep}
+     */
+    static removeAllUnaryOps() {
+      Jsep.unary_ops = {};
+      Jsep.max_unop_len = 0;
+      return Jsep;
+    }
+    /**
+     * @method removeIdentifierChar
+     * @param {string} char The additional character to stop treating as a valid part of an identifier
+     * @returns {Jsep}
+     */
+    static removeIdentifierChar(char) {
+      Jsep.additional_identifier_chars.delete(char);
+      return Jsep;
+    }
+    /**
+     * @method removeBinaryOp
+     * @param {string} op_name The name of the binary op to remove
+     * @returns {Jsep}
+     */
+    static removeBinaryOp(op_name) {
+      delete Jsep.binary_ops[op_name];
+      if (op_name.length === Jsep.max_binop_len) {
+        Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);
+      }
+      Jsep.right_associative.delete(op_name);
+      return Jsep;
+    }
+    /**
+     * @method removeAllBinaryOps
+     * @returns {Jsep}
+     */
+    static removeAllBinaryOps() {
+      Jsep.binary_ops = {};
+      Jsep.max_binop_len = 0;
+      return Jsep;
+    }
+    /**
+     * @method removeLiteral
+     * @param {string} literal_name The name of the literal to remove
+     * @returns {Jsep}
+     */
+    static removeLiteral(literal_name) {
+      delete Jsep.literals[literal_name];
+      return Jsep;
+    }
+    /**
+     * @method removeAllLiterals
+     * @returns {Jsep}
+     */
+    static removeAllLiterals() {
+      Jsep.literals = {};
+      return Jsep;
+    }
+    // ==================== END CONFIG ============================
+    /**
+     * @returns {string}
+     */
+    get char() {
+      return this.expr.charAt(this.index);
+    }
+    /**
+     * @returns {number}
+     */
+    get code() {
+      return this.expr.charCodeAt(this.index);
+    }
+    /**
+     * @param {string} expr a string with the passed in express
+     * @returns Jsep
+     */
+    constructor(expr) {
+      this.expr = expr;
+      this.index = 0;
+    }
+    /**
+     * static top-level parser
+     * @returns {jsep.Expression}
+     */
+    static parse(expr) {
+      return new Jsep(expr).parse();
+    }
+    /**
+     * Get the longest key length of any object
+     * @param {object} obj
+     * @returns {number}
+     */
+    static getMaxKeyLen(obj) {
+      return Math.max(0, ...Object.keys(obj).map((k) => k.length));
+    }
+    /**
+     * `ch` is a character code in the next three functions
+     * @param {number} ch
+     * @returns {boolean}
+     */
+    static isDecimalDigit(ch) {
+      return ch >= 48 && ch <= 57;
+    }
+    /**
+     * Returns the precedence of a binary operator or `0` if it isn't a binary operator. Can be float.
+     * @param {string} op_val
+     * @returns {number}
+     */
+    static binaryPrecedence(op_val) {
+      return Jsep.binary_ops[op_val] || 0;
+    }
+    /**
+     * Looks for start of identifier
+     * @param {number} ch
+     * @returns {boolean}
+     */
+    static isIdentifierStart(ch) {
+      return ch >= 65 && ch <= 90 || // A...Z
+      ch >= 97 && ch <= 122 || // a...z
+      ch >= 128 && !Jsep.binary_ops[String.fromCharCode(ch)] || // any non-ASCII that is not an operator
+      Jsep.additional_identifier_chars.has(String.fromCharCode(ch));
+    }
+    /**
+     * @param {number} ch
+     * @returns {boolean}
+     */
+    static isIdentifierPart(ch) {
+      return Jsep.isIdentifierStart(ch) || Jsep.isDecimalDigit(ch);
+    }
+    /**
+     * throw error at index of the expression
+     * @param {string} message
+     * @throws
+     */
+    throwError(message) {
+      const error = new Error(message + " at character " + this.index);
+      error.index = this.index;
+      error.description = message;
+      throw error;
+    }
+    /**
+     * Run a given hook
+     * @param {string} name
+     * @param {jsep.Expression|false} [node]
+     * @returns {?jsep.Expression}
+     */
+    runHook(name, node) {
+      if (Jsep.hooks[name]) {
+        const env = { context: this, node };
+        Jsep.hooks.run(name, env);
+        return env.node;
+      }
+      return node;
+    }
+    /**
+     * Runs a given hook until one returns a node
+     * @param {string} name
+     * @returns {?jsep.Expression}
+     */
+    searchHook(name) {
+      if (Jsep.hooks[name]) {
+        const env = { context: this };
+        Jsep.hooks[name].find(function(callback) {
+          callback.call(env.context, env);
+          return env.node;
+        });
+        return env.node;
+      }
+    }
+    /**
+     * Push `index` up to the next non-space character
+     */
+    gobbleSpaces() {
+      let ch = this.code;
+      while (ch === Jsep.SPACE_CODE || ch === Jsep.TAB_CODE || ch === Jsep.LF_CODE || ch === Jsep.CR_CODE) {
+        ch = this.expr.charCodeAt(++this.index);
+      }
+      this.runHook("gobble-spaces");
+    }
+    /**
+     * Top-level method to parse all expressions and returns compound or single node
+     * @returns {jsep.Expression}
+     */
+    parse() {
+      this.runHook("before-all");
+      const nodes = this.gobbleExpressions();
+      const node = nodes.length === 1 ? nodes[0] : {
+        type: Jsep.COMPOUND,
+        body: nodes
+      };
+      return this.runHook("after-all", node);
+    }
+    /**
+     * top-level parser (but can be reused within as well)
+     * @param {number} [untilICode]
+     * @returns {jsep.Expression[]}
+     */
+    gobbleExpressions(untilICode) {
+      let nodes = [], ch_i, node;
+      while (this.index < this.expr.length) {
+        ch_i = this.code;
+        if (ch_i === Jsep.SEMCOL_CODE || ch_i === Jsep.COMMA_CODE) {
+          this.index++;
+        } else {
+          if (node = this.gobbleExpression()) {
+            nodes.push(node);
+          } else if (this.index < this.expr.length) {
+            if (ch_i === untilICode) {
+              break;
+            }
+            this.throwError('Unexpected "' + this.char + '"');
+          }
+        }
+      }
+      return nodes;
+    }
+    /**
+     * The main parsing function.
+     * @returns {?jsep.Expression}
+     */
+    gobbleExpression() {
+      const node = this.searchHook("gobble-expression") || this.gobbleBinaryExpression();
+      this.gobbleSpaces();
+      return this.runHook("after-expression", node);
+    }
+    /**
+     * Search for the operation portion of the string (e.g. `+`, `===`)
+     * Start by taking the longest possible binary operations (3 characters: `===`, `!==`, `>>>`)
+     * and move down from 3 to 2 to 1 character until a matching binary operation is found
+     * then, return that binary operation
+     * @returns {string|boolean}
+     */
+    gobbleBinaryOp() {
+      this.gobbleSpaces();
+      let to_check = this.expr.substr(this.index, Jsep.max_binop_len);
+      let tc_len = to_check.length;
+      while (tc_len > 0) {
+        if (Jsep.binary_ops.hasOwnProperty(to_check) && (!Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {
+          this.index += tc_len;
+          return to_check;
+        }
+        to_check = to_check.substr(0, --tc_len);
+      }
+      return false;
+    }
+    /**
+     * This function is responsible for gobbling an individual expression,
+     * e.g. `1`, `1+2`, `a+(b*2)-Math.sqrt(2)`
+     * @returns {?jsep.BinaryExpression}
+     */
+    gobbleBinaryExpression() {
+      let node, biop, prec, stack, biop_info, left, right, i, cur_biop;
+      left = this.gobbleToken();
+      if (!left) {
+        return left;
+      }
+      biop = this.gobbleBinaryOp();
+      if (!biop) {
+        return left;
+      }
+      biop_info = { value: biop, prec: Jsep.binaryPrecedence(biop), right_a: Jsep.right_associative.has(biop) };
+      right = this.gobbleToken();
+      if (!right) {
+        this.throwError("Expected expression after " + biop);
+      }
+      stack = [left, biop_info, right];
+      while (biop = this.gobbleBinaryOp()) {
+        prec = Jsep.binaryPrecedence(biop);
+        if (prec === 0) {
+          this.index -= biop.length;
+          break;
+        }
+        biop_info = { value: biop, prec, right_a: Jsep.right_associative.has(biop) };
+        cur_biop = biop;
+        const comparePrev = (prev) => biop_info.right_a && prev.right_a ? prec > prev.prec : prec <= prev.prec;
+        while (stack.length > 2 && comparePrev(stack[stack.length - 2])) {
+          right = stack.pop();
+          biop = stack.pop().value;
+          left = stack.pop();
+          node = {
+            type: Jsep.BINARY_EXP,
+            operator: biop,
+            left,
+            right
+          };
+          stack.push(node);
+        }
+        node = this.gobbleToken();
+        if (!node) {
+          this.throwError("Expected expression after " + cur_biop);
+        }
+        stack.push(biop_info, node);
+      }
+      i = stack.length - 1;
+      node = stack[i];
+      while (i > 1) {
+        node = {
+          type: Jsep.BINARY_EXP,
+          operator: stack[i - 1].value,
+          left: stack[i - 2],
+          right: node
+        };
+        i -= 2;
+      }
+      return node;
+    }
+    /**
+     * An individual part of a binary expression:
+     * e.g. `foo.bar(baz)`, `1`, `"abc"`, `(a % 2)` (because it's in parenthesis)
+     * @returns {boolean|jsep.Expression}
+     */
+    gobbleToken() {
+      let ch, to_check, tc_len, node;
+      this.gobbleSpaces();
+      node = this.searchHook("gobble-token");
+      if (node) {
+        return this.runHook("after-token", node);
+      }
+      ch = this.code;
+      if (Jsep.isDecimalDigit(ch) || ch === Jsep.PERIOD_CODE) {
+        return this.gobbleNumericLiteral();
+      }
+      if (ch === Jsep.SQUOTE_CODE || ch === Jsep.DQUOTE_CODE) {
+        node = this.gobbleStringLiteral();
+      } else if (ch === Jsep.OBRACK_CODE) {
+        node = this.gobbleArray();
+      } else {
+        to_check = this.expr.substr(this.index, Jsep.max_unop_len);
+        tc_len = to_check.length;
+        while (tc_len > 0) {
+          if (Jsep.unary_ops.hasOwnProperty(to_check) && (!Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {
+            this.index += tc_len;
+            const argument = this.gobbleToken();
+            if (!argument) {
+              this.throwError("missing unaryOp argument");
+            }
+            return this.runHook("after-token", {
+              type: Jsep.UNARY_EXP,
+              operator: to_check,
+              argument,
+              prefix: true
+            });
+          }
+          to_check = to_check.substr(0, --tc_len);
+        }
+        if (Jsep.isIdentifierStart(ch)) {
+          node = this.gobbleIdentifier();
+          if (Jsep.literals.hasOwnProperty(node.name)) {
+            node = {
+              type: Jsep.LITERAL,
+              value: Jsep.literals[node.name],
+              raw: node.name
+            };
+          } else if (node.name === Jsep.this_str) {
+            node = { type: Jsep.THIS_EXP };
+          }
+        } else if (ch === Jsep.OPAREN_CODE) {
+          node = this.gobbleGroup();
+        }
+      }
+      if (!node) {
+        return this.runHook("after-token", false);
+      }
+      node = this.gobbleTokenProperty(node);
+      return this.runHook("after-token", node);
+    }
+    /**
+     * Gobble properties of of identifiers/strings/arrays/groups.
+     * e.g. `foo`, `bar.baz`, `foo['bar'].baz`
+     * It also gobbles function calls:
+     * e.g. `Math.acos(obj.angle)`
+     * @param {jsep.Expression} node
+     * @returns {jsep.Expression}
+     */
+    gobbleTokenProperty(node) {
+      this.gobbleSpaces();
+      let ch = this.code;
+      while (ch === Jsep.PERIOD_CODE || ch === Jsep.OBRACK_CODE || ch === Jsep.OPAREN_CODE || ch === Jsep.QUMARK_CODE) {
+        let optional;
+        if (ch === Jsep.QUMARK_CODE) {
+          if (this.expr.charCodeAt(this.index + 1) !== Jsep.PERIOD_CODE) {
+            break;
+          }
+          optional = true;
+          this.index += 2;
+          this.gobbleSpaces();
+          ch = this.code;
+        }
+        this.index++;
+        if (ch === Jsep.OBRACK_CODE) {
+          node = {
+            type: Jsep.MEMBER_EXP,
+            computed: true,
+            object: node,
+            property: this.gobbleExpression()
+          };
+          if (!node.property) {
+            this.throwError('Unexpected "' + this.char + '"');
+          }
+          this.gobbleSpaces();
+          ch = this.code;
+          if (ch !== Jsep.CBRACK_CODE) {
+            this.throwError("Unclosed [");
+          }
+          this.index++;
+        } else if (ch === Jsep.OPAREN_CODE) {
+          node = {
+            type: Jsep.CALL_EXP,
+            "arguments": this.gobbleArguments(Jsep.CPAREN_CODE),
+            callee: node
+          };
+        } else if (ch === Jsep.PERIOD_CODE || optional) {
+          if (optional) {
+            this.index--;
+          }
+          this.gobbleSpaces();
+          node = {
+            type: Jsep.MEMBER_EXP,
+            computed: false,
+            object: node,
+            property: this.gobbleIdentifier()
+          };
+        }
+        if (optional) {
+          node.optional = true;
+        }
+        this.gobbleSpaces();
+        ch = this.code;
+      }
+      return node;
+    }
+    /**
+     * Parse simple numeric literals: `12`, `3.4`, `.5`. Do this by using a string to
+     * keep track of everything in the numeric literal and then calling `parseFloat` on that string
+     * @returns {jsep.Literal}
+     */
+    gobbleNumericLiteral() {
+      let number3 = "", ch, chCode;
+      while (Jsep.isDecimalDigit(this.code)) {
+        number3 += this.expr.charAt(this.index++);
+      }
+      if (this.code === Jsep.PERIOD_CODE) {
+        number3 += this.expr.charAt(this.index++);
+        while (Jsep.isDecimalDigit(this.code)) {
+          number3 += this.expr.charAt(this.index++);
+        }
+      }
+      ch = this.char;
+      if (ch === "e" || ch === "E") {
+        number3 += this.expr.charAt(this.index++);
+        ch = this.char;
+        if (ch === "+" || ch === "-") {
+          number3 += this.expr.charAt(this.index++);
+        }
+        while (Jsep.isDecimalDigit(this.code)) {
+          number3 += this.expr.charAt(this.index++);
+        }
+        if (!Jsep.isDecimalDigit(this.expr.charCodeAt(this.index - 1))) {
+          this.throwError("Expected exponent (" + number3 + this.char + ")");
+        }
+      }
+      chCode = this.code;
+      if (Jsep.isIdentifierStart(chCode)) {
+        this.throwError("Variable names cannot start with a number (" + number3 + this.char + ")");
+      } else if (chCode === Jsep.PERIOD_CODE || number3.length === 1 && number3.charCodeAt(0) === Jsep.PERIOD_CODE) {
+        this.throwError("Unexpected period");
+      }
+      return {
+        type: Jsep.LITERAL,
+        value: parseFloat(number3),
+        raw: number3
+      };
+    }
+    /**
+     * Parses a string literal, staring with single or double quotes with basic support for escape codes
+     * e.g. `"hello world"`, `'this is\nJSEP'`
+     * @returns {jsep.Literal}
+     */
+    gobbleStringLiteral() {
+      let str = "";
+      const startIndex = this.index;
+      const quote = this.expr.charAt(this.index++);
+      let closed = false;
+      while (this.index < this.expr.length) {
+        let ch = this.expr.charAt(this.index++);
+        if (ch === quote) {
+          closed = true;
+          break;
+        } else if (ch === "\\") {
+          ch = this.expr.charAt(this.index++);
+          switch (ch) {
+            case "n":
+              str += "\n";
+              break;
+            case "r":
+              str += "\r";
+              break;
+            case "t":
+              str += "	";
+              break;
+            case "b":
+              str += "\b";
+              break;
+            case "f":
+              str += "\f";
+              break;
+            case "v":
+              str += "\v";
+              break;
+            default:
+              str += ch;
+          }
+        } else {
+          str += ch;
+        }
+      }
+      if (!closed) {
+        this.throwError('Unclosed quote after "' + str + '"');
+      }
+      return {
+        type: Jsep.LITERAL,
+        value: str,
+        raw: this.expr.substring(startIndex, this.index)
+      };
+    }
+    /**
+     * Gobbles only identifiers
+     * e.g.: `foo`, `_value`, `$x1`
+     * Also, this function checks if that identifier is a literal:
+     * (e.g. `true`, `false`, `null`) or `this`
+     * @returns {jsep.Identifier}
+     */
+    gobbleIdentifier() {
+      let ch = this.code, start = this.index;
+      if (Jsep.isIdentifierStart(ch)) {
+        this.index++;
+      } else {
+        this.throwError("Unexpected " + this.char);
+      }
+      while (this.index < this.expr.length) {
+        ch = this.code;
+        if (Jsep.isIdentifierPart(ch)) {
+          this.index++;
+        } else {
+          break;
+        }
+      }
+      return {
+        type: Jsep.IDENTIFIER,
+        name: this.expr.slice(start, this.index)
+      };
+    }
+    /**
+     * Gobbles a list of arguments within the context of a function call
+     * or array literal. This function also assumes that the opening character
+     * `(` or `[` has already been gobbled, and gobbles expressions and commas
+     * until the terminator character `)` or `]` is encountered.
+     * e.g. `foo(bar, baz)`, `my_func()`, or `[bar, baz]`
+     * @param {number} termination
+     * @returns {jsep.Expression[]}
+     */
+    gobbleArguments(termination) {
+      const args = [];
+      let closed = false;
+      let separator_count = 0;
+      while (this.index < this.expr.length) {
+        this.gobbleSpaces();
+        let ch_i = this.code;
+        if (ch_i === termination) {
+          closed = true;
+          this.index++;
+          if (termination === Jsep.CPAREN_CODE && separator_count && separator_count >= args.length) {
+            this.throwError("Unexpected token " + String.fromCharCode(termination));
+          }
+          break;
+        } else if (ch_i === Jsep.COMMA_CODE) {
+          this.index++;
+          separator_count++;
+          if (separator_count !== args.length) {
+            if (termination === Jsep.CPAREN_CODE) {
+              this.throwError("Unexpected token ,");
+            } else if (termination === Jsep.CBRACK_CODE) {
+              for (let arg = args.length; arg < separator_count; arg++) {
+                args.push(null);
+              }
+            }
+          }
+        } else if (args.length !== separator_count && separator_count !== 0) {
+          this.throwError("Expected comma");
+        } else {
+          const node = this.gobbleExpression();
+          if (!node || node.type === Jsep.COMPOUND) {
+            this.throwError("Expected comma");
+          }
+          args.push(node);
+        }
+      }
+      if (!closed) {
+        this.throwError("Expected " + String.fromCharCode(termination));
+      }
+      return args;
+    }
+    /**
+     * Responsible for parsing a group of things within parentheses `()`
+     * that have no identifier in front (so not a function call)
+     * This function assumes that it needs to gobble the opening parenthesis
+     * and then tries to gobble everything within that parenthesis, assuming
+     * that the next thing it should see is the close parenthesis. If not,
+     * then the expression probably doesn't have a `)`
+     * @returns {boolean|jsep.Expression}
+     */
+    gobbleGroup() {
+      this.index++;
+      let nodes = this.gobbleExpressions(Jsep.CPAREN_CODE);
+      if (this.code === Jsep.CPAREN_CODE) {
+        this.index++;
+        if (nodes.length === 1) {
+          return nodes[0];
+        } else if (!nodes.length) {
+          return false;
+        } else {
+          return {
+            type: Jsep.SEQUENCE_EXP,
+            expressions: nodes
+          };
+        }
+      } else {
+        this.throwError("Unclosed (");
+      }
+    }
+    /**
+     * Responsible for parsing Array literals `[1, 2, 3]`
+     * This function assumes that it needs to gobble the opening bracket
+     * and then tries to gobble the expressions as arguments.
+     * @returns {jsep.ArrayExpression}
+     */
+    gobbleArray() {
+      this.index++;
+      return {
+        type: Jsep.ARRAY_EXP,
+        elements: this.gobbleArguments(Jsep.CBRACK_CODE)
+      };
+    }
+  };
+  var hooks = new Hooks();
+  Object.assign(Jsep, {
+    hooks,
+    plugins: new Plugins(Jsep),
+    // Node Types
+    // ----------
+    // This is the full set of types that any JSEP node can be.
+    // Store them here to save space when minified
+    COMPOUND: "Compound",
+    SEQUENCE_EXP: "SequenceExpression",
+    IDENTIFIER: "Identifier",
+    MEMBER_EXP: "MemberExpression",
+    LITERAL: "Literal",
+    THIS_EXP: "ThisExpression",
+    CALL_EXP: "CallExpression",
+    UNARY_EXP: "UnaryExpression",
+    BINARY_EXP: "BinaryExpression",
+    ARRAY_EXP: "ArrayExpression",
+    TAB_CODE: 9,
+    LF_CODE: 10,
+    CR_CODE: 13,
+    SPACE_CODE: 32,
+    PERIOD_CODE: 46,
+    // '.'
+    COMMA_CODE: 44,
+    // ','
+    SQUOTE_CODE: 39,
+    // single quote
+    DQUOTE_CODE: 34,
+    // double quotes
+    OPAREN_CODE: 40,
+    // (
+    CPAREN_CODE: 41,
+    // )
+    OBRACK_CODE: 91,
+    // [
+    CBRACK_CODE: 93,
+    // ]
+    QUMARK_CODE: 63,
+    // ?
+    SEMCOL_CODE: 59,
+    // ;
+    COLON_CODE: 58,
+    // :
+    // Operations
+    // ----------
+    // Use a quickly-accessible map to store all of the unary operators
+    // Values are set to `1` (it really doesn't matter)
+    unary_ops: {
+      "-": 1,
+      "!": 1,
+      "~": 1,
+      "+": 1
+    },
+    // Also use a map for the binary operations but set their values to their
+    // binary precedence for quick reference (higher number = higher precedence)
+    // see [Order of operations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)
+    binary_ops: {
+      "||": 1,
+      "??": 1,
+      "&&": 2,
+      "|": 3,
+      "^": 4,
+      "&": 5,
+      "==": 6,
+      "!=": 6,
+      "===": 6,
+      "!==": 6,
+      "<": 7,
+      ">": 7,
+      "<=": 7,
+      ">=": 7,
+      "<<": 8,
+      ">>": 8,
+      ">>>": 8,
+      "+": 9,
+      "-": 9,
+      "*": 10,
+      "/": 10,
+      "%": 10,
+      "**": 11
+    },
+    // sets specific binary_ops as right-associative
+    right_associative: /* @__PURE__ */ new Set(["**"]),
+    // Additional valid identifier chars, apart from a-z, A-Z and 0-9 (except on the starting char)
+    additional_identifier_chars: /* @__PURE__ */ new Set(["$", "_"]),
+    // Literals
+    // ----------
+    // Store the values to return for the various literals we may encounter
+    literals: {
+      "true": true,
+      "false": false,
+      "null": null
+    },
+    // Except for `this`, which is special. This could be changed to something like `'self'` as well
+    this_str: "this"
+  });
+  Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);
+  Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);
+  var jsep = (expr) => new Jsep(expr).parse();
+  var stdClassProps = Object.getOwnPropertyNames(class Test {
+  });
+  Object.getOwnPropertyNames(Jsep).filter((prop) => !stdClassProps.includes(prop) && jsep[prop] === void 0).forEach((m) => {
+    jsep[m] = Jsep[m];
+  });
+  jsep.Jsep = Jsep;
+  var CONDITIONAL_EXP = "ConditionalExpression";
+  var ternary = {
+    name: "ternary",
+    init(jsep2) {
+      jsep2.hooks.add("after-expression", function gobbleTernary(env) {
+        if (env.node && this.code === jsep2.QUMARK_CODE) {
+          this.index++;
+          const test = env.node;
+          const consequent = this.gobbleExpression();
+          if (!consequent) {
+            this.throwError("Expected expression");
+          }
+          this.gobbleSpaces();
+          if (this.code === jsep2.COLON_CODE) {
+            this.index++;
+            const alternate = this.gobbleExpression();
+            if (!alternate) {
+              this.throwError("Expected expression");
+            }
+            env.node = {
+              type: CONDITIONAL_EXP,
+              test,
+              consequent,
+              alternate
+            };
+            if (test.operator && jsep2.binary_ops[test.operator] <= 0.9) {
+              let newTest = test;
+              while (newTest.right.operator && jsep2.binary_ops[newTest.right.operator] <= 0.9) {
+                newTest = newTest.right;
+              }
+              env.node.test = newTest.right;
+              newTest.right = env.node;
+              env.node = test;
+            }
+          } else {
+            this.throwError("Expected :");
+          }
+        }
+      });
+    }
+  };
+  jsep.plugins.register(ternary);
 
   // ../../node_modules/d3-array/src/ascending.js
   function ascending(a, b) {
@@ -11103,11 +12113,11 @@ void main(void) {
     FilterType2["STRING_SEARCH"] = "stringSearch";
     return FilterType2;
   })(FilterType || {});
-  var ApiVersion = /* @__PURE__ */ ((ApiVersion3) => {
-    ApiVersion3["V1"] = "v1";
-    ApiVersion3["V2"] = "v2";
-    ApiVersion3["V3"] = "v3";
-    return ApiVersion3;
+  var ApiVersion = /* @__PURE__ */ ((ApiVersion2) => {
+    ApiVersion2["V1"] = "v1";
+    ApiVersion2["V2"] = "v2";
+    ApiVersion2["V3"] = "v3";
+    return ApiVersion2;
   })(ApiVersion || {});
   var DEFAULT_API_BASE_URL = "https://gcp-us-east1.api.carto.com";
   var SpatialIndex = /* @__PURE__ */ ((SpatialIndex2) => {
@@ -12520,6 +13530,100 @@ void main(void) {
     }
     return Array.from(map2.values());
   }
+  var RADIANS_TO_DEGREES2 = 1 / Math.PI * 180;
+  var DEGREES_TO_RADIANS3 = 1 / 180 * Math.PI;
+  var DEFAULT_CONFIG = {
+    EPSILON: 1e-12,
+    debug: false,
+    precision: 4,
+    printTypes: false,
+    printDegrees: false,
+    printRowMajor: true,
+    _cartographicRadians: false
+  };
+  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
+  var config = globalThis.mathgl.config;
+  function isArray(value) {
+    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+  }
+  function lerp2(a, b, t) {
+    if (isArray(a)) {
+      return a.map((ai, i) => lerp2(ai, b[i], t));
+    }
+    return t * b + (1 - t) * a;
+  }
+  function assert3(condition, message) {
+    if (!condition) {
+      throw new Error(message || "@math.gl/web-mercator: assertion failed.");
+    }
+  }
+  var PI2 = Math.PI;
+  var PI_42 = PI2 / 4;
+  var DEGREES_TO_RADIANS22 = PI2 / 180;
+  var RADIANS_TO_DEGREES22 = 180 / PI2;
+  var TILE_SIZE4 = 512;
+  function lngLatToWorld2(lngLat) {
+    const [lng, lat] = lngLat;
+    assert3(Number.isFinite(lng));
+    assert3(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude");
+    const lambda2 = lng * DEGREES_TO_RADIANS22;
+    const phi2 = lat * DEGREES_TO_RADIANS22;
+    const x = TILE_SIZE4 * (lambda2 + PI2) / (2 * PI2);
+    const y = TILE_SIZE4 * (PI2 + Math.log(Math.tan(PI_42 + phi2 * 0.5))) / (2 * PI2);
+    return [x, y];
+  }
+  function worldToLngLat2(xy) {
+    const [x, y] = xy;
+    const lambda2 = x / TILE_SIZE4 * (2 * PI2) - PI2;
+    const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE4 * (2 * PI2) - PI2)) - PI_42);
+    return [lambda2 * RADIANS_TO_DEGREES22, phi2 * RADIANS_TO_DEGREES22];
+  }
+  var DEGREES_TO_RADIANS32 = Math.PI / 180;
+  var TRANSFORM_FN = {
+    Point: transformPoint,
+    MultiPoint: transformMultiPoint,
+    LineString: transformLineString,
+    MultiLineString: transformMultiLineString,
+    Polygon: transformPolygon,
+    MultiPolygon: transformMultiPolygon
+  };
+  function transformTileCoordsToWGS84(geometry, bbox2) {
+    const [west, south, east, north] = bbox2;
+    const nw = lngLatToWorld2([west, north]);
+    const se = lngLatToWorld2([east, south]);
+    const projectedBbox = [nw, se];
+    if (geometry.type === "GeometryCollection") {
+      throw new Error("Unsupported geometry type GeometryCollection");
+    }
+    const transformFn = TRANSFORM_FN[geometry.type];
+    const coordinates = transformFn(geometry.coordinates, projectedBbox);
+    return { ...geometry, coordinates };
+  }
+  function transformPoint([pointX, pointY], [nw, se]) {
+    const x = lerp2(nw[0], se[0], pointX);
+    const y = lerp2(nw[1], se[1], pointY);
+    return worldToLngLat2([x, y]);
+  }
+  function getPoints(geometry, bbox2) {
+    return geometry.map((g) => transformPoint(g, bbox2));
+  }
+  function transformMultiPoint(multiPoint, bbox2) {
+    return getPoints(multiPoint, bbox2);
+  }
+  function transformLineString(line, bbox2) {
+    return getPoints(line, bbox2);
+  }
+  function transformMultiLineString(multiLineString2, bbox2) {
+    return multiLineString2.map(
+      (lineString2) => transformLineString(lineString2, bbox2)
+    );
+  }
+  function transformPolygon(polygon2, bbox2) {
+    return polygon2.map((polygonRing) => getPoints(polygonRing, bbox2));
+  }
+  function transformMultiPolygon(multiPolygon2, bbox2) {
+    return multiPolygon2.map((polygon2) => transformPolygon(polygon2, bbox2));
+  }
   function bboxPolygon(bbox2, options = {}) {
     const west = Number(bbox2[0]);
     const south = Number(bbox2[1]);
@@ -12833,7 +13937,7 @@ void main(void) {
   var POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13];
   var SQRT_BASE = 1e7;
   var MAX = 1e9;
-  function clone(configObject) {
+  function clone2(configObject) {
     var div, convertBase, parseNumeric, P = BigNumber2.prototype = { constructor: BigNumber2, toString: null, valueOf: null }, ONE = new BigNumber2(1), DECIMAL_PLACES = 20, ROUNDING_MODE = 4, TO_EXP_NEG = -7, TO_EXP_POS = 21, MIN_EXP = -1e7, MAX_EXP = 1e7, CRYPTO = false, MODULO_MODE = 1, POW_PRECISION = 0, FORMAT = {
       prefix: "",
       groupSize: 3,
@@ -12972,7 +14076,7 @@ void main(void) {
         x.c = [x.e = 0];
       }
     }
-    BigNumber2.clone = clone;
+    BigNumber2.clone = clone2;
     BigNumber2.ROUND_UP = 0;
     BigNumber2.ROUND_DOWN = 1;
     BigNumber2.ROUND_CEIL = 2;
@@ -14292,7 +15396,7 @@ void main(void) {
     }
     return str;
   }
-  var BigNumber = clone();
+  var BigNumber = clone2();
   var bignumber_default = BigNumber;
   var SplayTreeNode = class {
     constructor(key) {
@@ -16011,62 +17115,13 @@ void main(void) {
     return multiPolygon(intersection22, options.properties);
   }
   var turf_intersect_default = intersect;
-  var RADIANS_TO_DEGREES2 = 1 / Math.PI * 180;
-  var DEGREES_TO_RADIANS3 = 1 / 180 * Math.PI;
-  var DEFAULT_CONFIG = {
-    EPSILON: 1e-12,
-    debug: false,
-    precision: 4,
-    printTypes: false,
-    printDegrees: false,
-    printRowMajor: true,
-    _cartographicRadians: false
-  };
-  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
-  var config = globalThis.mathgl.config;
-  function isArray(value) {
-    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
-  }
-  function lerp2(a, b, t) {
-    if (isArray(a)) {
-      return a.map((ai, i) => lerp2(ai, b[i], t));
-    }
-    return t * b + (1 - t) * a;
-  }
-  function assert3(condition, message) {
-    if (!condition) {
-      throw new Error(message || "@math.gl/web-mercator: assertion failed.");
-    }
-  }
-  var PI2 = Math.PI;
-  var PI_42 = PI2 / 4;
-  var DEGREES_TO_RADIANS22 = PI2 / 180;
-  var RADIANS_TO_DEGREES22 = 180 / PI2;
-  var TILE_SIZE3 = 512;
-  function lngLatToWorld2(lngLat) {
-    const [lng, lat] = lngLat;
-    assert3(Number.isFinite(lng));
-    assert3(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude");
-    const lambda2 = lng * DEGREES_TO_RADIANS22;
-    const phi2 = lat * DEGREES_TO_RADIANS22;
-    const x = TILE_SIZE3 * (lambda2 + PI2) / (2 * PI2);
-    const y = TILE_SIZE3 * (PI2 + Math.log(Math.tan(PI_42 + phi2 * 0.5))) / (2 * PI2);
-    return [x, y];
-  }
-  function worldToLngLat2(xy) {
-    const [x, y] = xy;
-    const lambda2 = x / TILE_SIZE3 * (2 * PI2) - PI2;
-    const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE3 * (2 * PI2) - PI2)) - PI_42);
-    return [lambda2 * RADIANS_TO_DEGREES22, phi2 * RADIANS_TO_DEGREES22];
-  }
-  var DEGREES_TO_RADIANS32 = Math.PI / 180;
-  var TRANSFORM_FN = {
-    Point: transformPoint,
-    MultiPoint: transformMultiPoint,
-    LineString: transformLineString,
-    MultiLineString: transformMultiLineString,
-    Polygon: transformPolygon,
-    MultiPolygon: transformMultiPolygon
+  var TRANSFORM_FN2 = {
+    Point: transformPoint2,
+    MultiPoint: transformMultiPoint2,
+    LineString: transformLineString2,
+    MultiLineString: transformMultiLineString2,
+    Polygon: transformPolygon2,
+    MultiPolygon: transformMultiPolygon2
   };
   function transformToTileCoords(geometry, bbox2) {
     const [west, south, east, north] = bbox2;
@@ -16076,34 +17131,34 @@ void main(void) {
     if (geometry.type === "GeometryCollection") {
       throw new Error("Unsupported geometry type GeometryCollection");
     }
-    const transformFn = TRANSFORM_FN[geometry.type];
+    const transformFn = TRANSFORM_FN2[geometry.type];
     const coordinates = transformFn(geometry.coordinates, projectedBbox);
     return { ...geometry, coordinates };
   }
-  function transformPoint([pointX, pointY], [nw, se]) {
+  function transformPoint2([pointX, pointY], [nw, se]) {
     const x = inverseLerp(nw[0], se[0], pointX);
     const y = inverseLerp(nw[1], se[1], pointY);
     return [x, y];
   }
-  function getPoints(geometry, bbox2) {
-    return geometry.map((g) => transformPoint(projectFlat(g), bbox2));
+  function getPoints2(geometry, bbox2) {
+    return geometry.map((g) => transformPoint2(projectFlat(g), bbox2));
   }
-  function transformMultiPoint(multiPoint, bbox2) {
-    return getPoints(multiPoint, bbox2);
+  function transformMultiPoint2(multiPoint, bbox2) {
+    return getPoints2(multiPoint, bbox2);
   }
-  function transformLineString(line, bbox2) {
-    return getPoints(line, bbox2);
+  function transformLineString2(line, bbox2) {
+    return getPoints2(line, bbox2);
   }
-  function transformMultiLineString(multiLineString2, bbox2) {
+  function transformMultiLineString2(multiLineString2, bbox2) {
     return multiLineString2.map(
-      (lineString2) => transformLineString(lineString2, bbox2)
+      (lineString2) => transformLineString2(lineString2, bbox2)
     );
   }
-  function transformPolygon(polygon2, bbox2) {
-    return polygon2.map((polygonRing) => getPoints(polygonRing, bbox2));
+  function transformPolygon2(polygon2, bbox2) {
+    return polygon2.map((polygonRing) => getPoints2(polygonRing, bbox2));
   }
-  function transformMultiPolygon(multiPolygon2, bbox2) {
-    return multiPolygon2.map((polygon2) => transformPolygon(polygon2, bbox2));
+  function transformMultiPolygon2(multiPolygon2, bbox2) {
+    return multiPolygon2.map((polygon2) => transformPolygon2(polygon2, bbox2));
   }
   function projectFlat(xyz) {
     return lngLatToWorld2(xyz);
@@ -16111,50 +17166,182 @@ void main(void) {
   function inverseLerp(a, b, x) {
     return (x - a) / (b - a);
   }
-  var TRANSFORM_FN2 = {
-    Point: transformPoint2,
-    MultiPoint: transformMultiPoint2,
-    LineString: transformLineString2,
-    MultiLineString: transformMultiLineString2,
-    Polygon: transformPolygon2,
-    MultiPolygon: transformMultiPolygon2
-  };
-  function transformTileCoordsToWGS84(geometry, bbox2) {
-    const [west, south, east, north] = bbox2;
-    const nw = lngLatToWorld2([west, north]);
-    const se = lngLatToWorld2([east, south]);
-    const projectedBbox = [nw, se];
-    if (geometry.type === "GeometryCollection") {
-      throw new Error("Unsupported geometry type GeometryCollection");
+  function lineclip(points, bbox2, result) {
+    var len = points.length, codeA = bitCode(points[0], bbox2), part = [], i, codeB, lastCode;
+    let a;
+    let b;
+    if (!result)
+      result = [];
+    for (i = 1; i < len; i++) {
+      a = points[i - 1];
+      b = points[i];
+      codeB = lastCode = bitCode(b, bbox2);
+      while (true) {
+        if (!(codeA | codeB)) {
+          part.push(a);
+          if (codeB !== lastCode) {
+            part.push(b);
+            if (i < len - 1) {
+              result.push(part);
+              part = [];
+            }
+          } else if (i === len - 1) {
+            part.push(b);
+          }
+          break;
+        } else if (codeA & codeB) {
+          break;
+        } else if (codeA) {
+          a = intersect2(a, b, codeA, bbox2);
+          codeA = bitCode(a, bbox2);
+        } else {
+          b = intersect2(a, b, codeB, bbox2);
+          codeB = bitCode(b, bbox2);
+        }
+      }
+      codeA = lastCode;
+    }
+    if (part.length)
+      result.push(part);
+    return result;
+  }
+  function polygonclip(points, bbox2) {
+    var result, edge, prev, prevInside, i, p, inside;
+    for (edge = 1; edge <= 8; edge *= 2) {
+      result = [];
+      prev = points[points.length - 1];
+      prevInside = !(bitCode(prev, bbox2) & edge);
+      for (i = 0; i < points.length; i++) {
+        p = points[i];
+        inside = !(bitCode(p, bbox2) & edge);
+        if (inside !== prevInside)
+          result.push(intersect2(prev, p, edge, bbox2));
+        if (inside)
+          result.push(p);
+        prev = p;
+        prevInside = inside;
+      }
+      points = result;
+      if (!points.length)
+        break;
     }
-    const transformFn = TRANSFORM_FN2[geometry.type];
-    const coordinates = transformFn(geometry.coordinates, projectedBbox);
-    return { ...geometry, coordinates };
+    return result;
   }
-  function transformPoint2([pointX, pointY], [nw, se]) {
-    const x = lerp2(nw[0], se[0], pointX);
-    const y = lerp2(nw[1], se[1], pointY);
-    return worldToLngLat2([x, y]);
+  function intersect2(a, b, edge, bbox2) {
+    return edge & 8 ? [a[0] + (b[0] - a[0]) * (bbox2[3] - a[1]) / (b[1] - a[1]), bbox2[3]] : edge & 4 ? [a[0] + (b[0] - a[0]) * (bbox2[1] - a[1]) / (b[1] - a[1]), bbox2[1]] : edge & 2 ? [bbox2[2], a[1] + (b[1] - a[1]) * (bbox2[2] - a[0]) / (b[0] - a[0])] : edge & 1 ? [bbox2[0], a[1] + (b[1] - a[1]) * (bbox2[0] - a[0]) / (b[0] - a[0])] : null;
   }
-  function getPoints2(geometry, bbox2) {
-    return geometry.map((g) => transformPoint2(g, bbox2));
+  function bitCode(p, bbox2) {
+    var code = 0;
+    if (p[0] < bbox2[0])
+      code |= 1;
+    else if (p[0] > bbox2[2])
+      code |= 2;
+    if (p[1] < bbox2[1])
+      code |= 4;
+    else if (p[1] > bbox2[3])
+      code |= 8;
+    return code;
   }
-  function transformMultiPoint2(multiPoint, bbox2) {
-    return getPoints2(multiPoint, bbox2);
+  function bboxClip(feature2, bbox2) {
+    const geom = getGeom(feature2);
+    const type = geom.type;
+    const properties = feature2.type === "Feature" ? feature2.properties : {};
+    let coords = geom.coordinates;
+    switch (type) {
+      case "LineString":
+      case "MultiLineString": {
+        const lines = [];
+        if (type === "LineString") {
+          coords = [coords];
+        }
+        coords.forEach((line) => {
+          lineclip(line, bbox2, lines);
+        });
+        if (lines.length === 1) {
+          return lineString(lines[0], properties);
+        }
+        return multiLineString(lines, properties);
+      }
+      case "Polygon":
+        return polygon(clipPolygon(coords, bbox2), properties);
+      case "MultiPolygon":
+        return multiPolygon(
+          coords.map((poly) => {
+            return clipPolygon(poly, bbox2);
+          }),
+          properties
+        );
+      default:
+        throw new Error("geometry " + type + " not supported");
+    }
   }
-  function transformLineString2(line, bbox2) {
-    return getPoints2(line, bbox2);
+  function clipPolygon(rings, bbox2) {
+    const outRings = [];
+    for (const ring of rings) {
+      const clipped = polygonclip(ring, bbox2);
+      if (clipped.length > 0) {
+        if (clipped[0][0] !== clipped[clipped.length - 1][0] || clipped[0][1] !== clipped[clipped.length - 1][1]) {
+          clipped.push(clipped[0]);
+        }
+        if (clipped.length >= 4) {
+          outRings.push(clipped);
+        }
+      }
+    }
+    return outRings;
   }
-  function transformMultiLineString2(multiLineString2, bbox2) {
-    return multiLineString2.map(
-      (lineString2) => transformLineString2(lineString2, bbox2)
+  var turf_bbox_clip_default = bboxClip;
+  function intersectTileGeometry(tileBbox, tileFormat, spatialFilter) {
+    const tilePolygon = turf_bbox_polygon_default(tileBbox);
+    if (!spatialFilter || turf_boolean_within_default(tilePolygon, spatialFilter)) {
+      return true;
+    }
+    const clippedSpatialFilter = turf_intersect_default(
+      featureCollection([tilePolygon, feature(spatialFilter)])
     );
+    if (!clippedSpatialFilter) {
+      return false;
+    }
+    return tileFormat === "mvt" ? transformToTileCoords(clippedSpatialFilter.geometry, tileBbox) : clippedSpatialFilter.geometry;
   }
-  function transformPolygon2(polygon2, bbox2) {
-    return polygon2.map((polygonRing) => getPoints2(polygonRing, bbox2));
+  function intersectTileRaster(parent, cellResolution, spatialFilter) {
+    return intersectTileQuadbin(parent, cellResolution, spatialFilter);
   }
-  function transformMultiPolygon2(multiPolygon2, bbox2) {
-    return multiPolygon2.map((polygon2) => transformPolygon2(polygon2, bbox2));
+  function intersectTileQuadbin(parent, cellResolution, spatialFilter) {
+    const tilePolygon = cellToBoundary2(parent);
+    if (!spatialFilter || turf_boolean_within_default(tilePolygon, spatialFilter)) {
+      return true;
+    }
+    const clippedSpatialFilter = turf_intersect_default(
+      featureCollection([feature(tilePolygon), feature(spatialFilter)])
+    );
+    if (!clippedSpatialFilter) {
+      return false;
+    }
+    const cells = geometryToCells(
+      clippedSpatialFilter.geometry,
+      cellResolution
+    );
+    return new Set(cells);
+  }
+  var BBOX_WEST = [-180, -90, 0, 90];
+  var BBOX_EAST = [0, -90, 180, 90];
+  function intersectTileH3(cellResolution, spatialFilter) {
+    if (!spatialFilter) {
+      return true;
+    }
+    const spatialFilterFeature = feature(spatialFilter);
+    const cellsWest = (0, import_h3_js5.polygonToCells)(
+      turf_bbox_clip_default(spatialFilterFeature, BBOX_WEST).geometry.coordinates,
+      cellResolution,
+      true
+    );
+    const cellsEast = (0, import_h3_js5.polygonToCells)(
+      turf_bbox_clip_default(spatialFilterFeature, BBOX_EAST).geometry.coordinates,
+      cellResolution,
+      true
+    );
+    return new Set(cellsWest.concat(cellsEast));
   }
   var FEATURE_GEOM_PROPERTY = "__geomValue";
   function tileFeaturesGeometries({
@@ -16169,55 +17356,46 @@ void main(void) {
       if (tile.isVisible === false || !tile.data) {
         continue;
       }
-      const bbox2 = [
+      const tileBbox = [
         tile.bbox.west,
         tile.bbox.south,
         tile.bbox.east,
         tile.bbox.north
       ];
-      const bboxToGeom = turf_bbox_polygon_default(bbox2);
-      const tileIsFullyVisible = turf_boolean_within_default(bboxToGeom, spatialFilter);
-      const spatialFilterFeature = {
-        type: "Feature",
-        geometry: spatialFilter,
-        properties: {}
-      };
-      const clippedGeometryToIntersect = turf_intersect_default(
-        featureCollection([bboxToGeom, spatialFilterFeature])
+      const intersection3 = intersectTileGeometry(
+        tileBbox,
+        tileFormat,
+        spatialFilter
       );
-      if (!clippedGeometryToIntersect) {
+      if (intersection3 === false)
         continue;
-      }
-      const transformedGeometryToIntersect = tileFormat === "mvt" ? transformToTileCoords(clippedGeometryToIntersect.geometry, bbox2) : clippedGeometryToIntersect.geometry;
+      const transformedSpatialFilter = intersection3 === true ? void 0 : intersection3;
       calculateFeatures({
         map: map2,
-        tileIsFullyVisible,
-        geometryIntersection: transformedGeometryToIntersect,
+        spatialFilter: transformedSpatialFilter,
         data: tile.data.points,
         type: "Point",
-        bbox: bbox2,
+        bbox: tileBbox,
         tileFormat,
         uniqueIdProperty,
         options
       });
       calculateFeatures({
         map: map2,
-        tileIsFullyVisible,
-        geometryIntersection: transformedGeometryToIntersect,
+        spatialFilter: transformedSpatialFilter,
         data: tile.data.lines,
         type: "LineString",
-        bbox: bbox2,
+        bbox: tileBbox,
         tileFormat,
         uniqueIdProperty,
         options
       });
       calculateFeatures({
         map: map2,
-        tileIsFullyVisible,
-        geometryIntersection: transformedGeometryToIntersect,
+        spatialFilter: transformedSpatialFilter,
         data: tile.data.polygons,
         type: "Polygon",
-        bbox: bbox2,
+        bbox: tileBbox,
         tileFormat,
         uniqueIdProperty,
         options
@@ -16235,7 +17413,7 @@ void main(void) {
     tileFormat,
     uniqueIdProperty,
     storeGeometry,
-    geometryIntersection
+    spatialFilter
   }) {
     const tileProps = getPropertiesFromTile(data, startIndex);
     const uniquePropertyValue = getUniquePropertyValue(
@@ -16247,7 +17425,7 @@ void main(void) {
       return;
     }
     let geometry = null;
-    if (storeGeometry || geometryIntersection) {
+    if (storeGeometry || spatialFilter) {
       const { positions } = data;
       const ringCoordinates = getRingCoordinatesFor(
         startIndex,
@@ -16256,7 +17434,7 @@ void main(void) {
       );
       geometry = getFeatureByType(ringCoordinates, type);
     }
-    if (geometry && geometryIntersection && !turf_boolean_intersects_default(geometry, geometryIntersection)) {
+    if (geometry && spatialFilter && !turf_boolean_intersects_default(geometry, spatialFilter)) {
       return;
     }
     const properties = parseProperties2(tileProps);
@@ -16268,7 +17446,7 @@ void main(void) {
   function addIntersectedFeaturesInTile({
     map: map2,
     data,
-    geometryIntersection,
+    spatialFilter,
     type,
     bbox: bbox2,
     tileFormat,
@@ -16290,7 +17468,7 @@ void main(void) {
         tileFormat,
         uniqueIdProperty,
         storeGeometry,
-        geometryIntersection
+        spatialFilter
       });
     }
   }
@@ -16372,8 +17550,7 @@ void main(void) {
   }
   function calculateFeatures({
     map: map2,
-    tileIsFullyVisible,
-    geometryIntersection,
+    spatialFilter,
     data,
     type,
     bbox: bbox2,
@@ -16384,7 +17561,7 @@ void main(void) {
     if (!data?.properties.length) {
       return;
     }
-    if (tileIsFullyVisible) {
+    if (!spatialFilter) {
       addAllFeaturesInTile({
         map: map2,
         data,
@@ -16398,7 +17575,7 @@ void main(void) {
       addIntersectedFeaturesInTile({
         map: map2,
         data,
-        geometryIntersection,
+        spatialFilter,
         type,
         bbox: bbox2,
         tileFormat,
@@ -16407,170 +17584,45 @@ void main(void) {
       });
     }
   }
-  function addAllFeaturesInTile({
-    map: map2,
-    data,
-    type,
-    bbox: bbox2,
-    tileFormat,
-    uniqueIdProperty,
-    options
-  }) {
-    const indices = getIndices(data, type);
-    const storeGeometry = options?.storeGeometry || false;
-    for (let i = 0; i < indices.length - 1; i++) {
-      const startIndex = indices[i];
-      const endIndex = indices[i + 1];
-      processTileFeatureProperties({
-        map: map2,
-        data,
-        startIndex,
-        endIndex,
-        type,
-        bbox: bbox2,
-        tileFormat,
-        uniqueIdProperty,
-        storeGeometry
-      });
-    }
-  }
-  function createIndicesForPoints(data) {
-    const featureIds = data.featureIds.value;
-    const lastFeatureId = featureIds[featureIds.length - 1];
-    const PointIndicesArray = featureIds.constructor;
-    const pointIndices = {
-      value: new PointIndicesArray(featureIds.length + 1),
-      size: 1
-    };
-    pointIndices.value.set(featureIds);
-    pointIndices.value.set([lastFeatureId + 1], featureIds.length);
-    return pointIndices;
-  }
-  function lineclip(points, bbox2, result) {
-    var len = points.length, codeA = bitCode(points[0], bbox2), part = [], i, codeB, lastCode;
-    let a;
-    let b;
-    if (!result)
-      result = [];
-    for (i = 1; i < len; i++) {
-      a = points[i - 1];
-      b = points[i];
-      codeB = lastCode = bitCode(b, bbox2);
-      while (true) {
-        if (!(codeA | codeB)) {
-          part.push(a);
-          if (codeB !== lastCode) {
-            part.push(b);
-            if (i < len - 1) {
-              result.push(part);
-              part = [];
-            }
-          } else if (i === len - 1) {
-            part.push(b);
-          }
-          break;
-        } else if (codeA & codeB) {
-          break;
-        } else if (codeA) {
-          a = intersect2(a, b, codeA, bbox2);
-          codeA = bitCode(a, bbox2);
-        } else {
-          b = intersect2(a, b, codeB, bbox2);
-          codeB = bitCode(b, bbox2);
-        }
-      }
-      codeA = lastCode;
-    }
-    if (part.length)
-      result.push(part);
-    return result;
-  }
-  function polygonclip(points, bbox2) {
-    var result, edge, prev, prevInside, i, p, inside;
-    for (edge = 1; edge <= 8; edge *= 2) {
-      result = [];
-      prev = points[points.length - 1];
-      prevInside = !(bitCode(prev, bbox2) & edge);
-      for (i = 0; i < points.length; i++) {
-        p = points[i];
-        inside = !(bitCode(p, bbox2) & edge);
-        if (inside !== prevInside)
-          result.push(intersect2(prev, p, edge, bbox2));
-        if (inside)
-          result.push(p);
-        prev = p;
-        prevInside = inside;
-      }
-      points = result;
-      if (!points.length)
-        break;
-    }
-    return result;
-  }
-  function intersect2(a, b, edge, bbox2) {
-    return edge & 8 ? [a[0] + (b[0] - a[0]) * (bbox2[3] - a[1]) / (b[1] - a[1]), bbox2[3]] : edge & 4 ? [a[0] + (b[0] - a[0]) * (bbox2[1] - a[1]) / (b[1] - a[1]), bbox2[1]] : edge & 2 ? [bbox2[2], a[1] + (b[1] - a[1]) * (bbox2[2] - a[0]) / (b[0] - a[0])] : edge & 1 ? [bbox2[0], a[1] + (b[1] - a[1]) * (bbox2[0] - a[0]) / (b[0] - a[0])] : null;
-  }
-  function bitCode(p, bbox2) {
-    var code = 0;
-    if (p[0] < bbox2[0])
-      code |= 1;
-    else if (p[0] > bbox2[2])
-      code |= 2;
-    if (p[1] < bbox2[1])
-      code |= 4;
-    else if (p[1] > bbox2[3])
-      code |= 8;
-    return code;
-  }
-  function bboxClip(feature2, bbox2) {
-    const geom = getGeom(feature2);
-    const type = geom.type;
-    const properties = feature2.type === "Feature" ? feature2.properties : {};
-    let coords = geom.coordinates;
-    switch (type) {
-      case "LineString":
-      case "MultiLineString": {
-        const lines = [];
-        if (type === "LineString") {
-          coords = [coords];
-        }
-        coords.forEach((line) => {
-          lineclip(line, bbox2, lines);
-        });
-        if (lines.length === 1) {
-          return lineString(lines[0], properties);
-        }
-        return multiLineString(lines, properties);
-      }
-      case "Polygon":
-        return polygon(clipPolygon(coords, bbox2), properties);
-      case "MultiPolygon":
-        return multiPolygon(
-          coords.map((poly) => {
-            return clipPolygon(poly, bbox2);
-          }),
-          properties
-        );
-      default:
-        throw new Error("geometry " + type + " not supported");
-    }
-  }
-  function clipPolygon(rings, bbox2) {
-    const outRings = [];
-    for (const ring of rings) {
-      const clipped = polygonclip(ring, bbox2);
-      if (clipped.length > 0) {
-        if (clipped[0][0] !== clipped[clipped.length - 1][0] || clipped[0][1] !== clipped[clipped.length - 1][1]) {
-          clipped.push(clipped[0]);
-        }
-        if (clipped.length >= 4) {
-          outRings.push(clipped);
-        }
-      }
+  function addAllFeaturesInTile({
+    map: map2,
+    data,
+    type,
+    bbox: bbox2,
+    tileFormat,
+    uniqueIdProperty,
+    options
+  }) {
+    const indices = getIndices(data, type);
+    const storeGeometry = options?.storeGeometry || false;
+    for (let i = 0; i < indices.length - 1; i++) {
+      const startIndex = indices[i];
+      const endIndex = indices[i + 1];
+      processTileFeatureProperties({
+        map: map2,
+        data,
+        startIndex,
+        endIndex,
+        type,
+        bbox: bbox2,
+        tileFormat,
+        uniqueIdProperty,
+        storeGeometry
+      });
     }
-    return outRings;
   }
-  var turf_bbox_clip_default = bboxClip;
+  function createIndicesForPoints(data) {
+    const featureIds = data.featureIds.value;
+    const lastFeatureId = featureIds[featureIds.length - 1];
+    const PointIndicesArray = featureIds.constructor;
+    const pointIndices = {
+      value: new PointIndicesArray(featureIds.length + 1),
+      size: 1
+    };
+    pointIndices.value.set(featureIds);
+    pointIndices.value.set([lastFeatureId + 1], featureIds.length);
+    return pointIndices;
+  }
   function tileFeaturesSpatialIndex({
     tiles: tiles3,
     spatialFilter,
@@ -16579,58 +17631,53 @@ void main(void) {
   }) {
     const map2 = /* @__PURE__ */ new Map();
     const spatialIndex = getSpatialIndex(spatialDataType);
-    const resolution = getResolution4(tiles3, spatialIndex);
+    const cellResolution = getResolution5(tiles3, spatialIndex);
     const spatialIndexIDName = spatialDataColumn ? spatialDataColumn : spatialIndex;
-    if (!resolution) {
+    if (!cellResolution) {
       return [];
     }
-    const cells = getCellsCoverGeometry(spatialFilter, spatialIndex, resolution);
-    if (!cells?.length) {
-      return [];
+    let intersection3;
+    if (spatialIndex === "h3") {
+      intersection3 = intersectTileH3(cellResolution, spatialFilter);
     }
-    const cellsSet = new Set(cells);
     for (const tile of tiles3) {
       if (tile.isVisible === false || !tile.data) {
         continue;
       }
+      if (spatialIndex === "quadbin") {
+        const parent = getTileIndex(tile, spatialIndex);
+        intersection3 = intersectTileQuadbin(
+          parent,
+          cellResolution,
+          spatialFilter
+        );
+      }
+      if (!intersection3)
+        continue;
       tile.data.forEach((d) => {
-        if (cellsSet.has(d.id)) {
+        if (intersection3 === true || intersection3.has(d.id)) {
           map2.set(d.id, { ...d.properties, [spatialIndexIDName]: d.id });
         }
       });
     }
     return Array.from(map2.values());
   }
-  function getResolution4(tiles3, spatialIndex) {
+  function getTileIndex(tile, spatialIndex) {
+    if (spatialIndex === "quadbin") {
+      return tile.index.q;
+    }
+    return tile.id;
+  }
+  function getResolution5(tiles3, spatialIndex) {
     const data = tiles3.find((tile) => tile.data?.length)?.data;
     if (!data) {
       return;
     }
     if (spatialIndex === "quadbin") {
-      return Number(getResolution3(data[0].id));
-    }
-    if (spatialIndex === "h3") {
-      return (0, import_h3_js3.getResolution)(data[0].id);
-    }
-  }
-  var bboxWest = [-180, -90, 0, 90];
-  var bboxEast = [0, -90, 180, 90];
-  function getCellsCoverGeometry(geometry, spatialIndex, resolution) {
-    if (spatialIndex === "quadbin") {
-      return geometryToCells(geometry, resolution);
+      return Number(getResolution4(data[0].id));
     }
     if (spatialIndex === "h3") {
-      return (0, import_h3_js3.polygonToCells)(
-        turf_bbox_clip_default(geometry, bboxWest).geometry.coordinates,
-        resolution,
-        true
-      ).concat(
-        (0, import_h3_js3.polygonToCells)(
-          turf_bbox_clip_default(geometry, bboxEast).geometry.coordinates,
-          resolution,
-          true
-        )
-      );
+      return (0, import_h3_js6.getResolution)(data[0].id);
     }
   }
   function getSpatialIndex(spatialDataType) {
@@ -16663,19 +17710,24 @@ void main(void) {
     tiles3 = tiles3.filter(isRasterTileVisible);
     if (tiles3.length === 0)
       return [];
-    const tileResolution = getResolution3(tiles3[0].index.q);
+    const tileResolution = getResolution4(tiles3[0].index.q);
     const tileBlockSize = tiles3[0].data.blockSize;
     const cellResolution = tileResolution + BigInt(Math.log2(tileBlockSize));
-    const spatialFilterCells = new Set(
-      geometryToCells(options.spatialFilter, cellResolution)
-    );
     const data = /* @__PURE__ */ new Map();
     for (const tile of tiles3) {
       const parent = tile.index.q;
-      const children = cellToChildrenSorted(parent, cellResolution);
-      for (let i = 0; i < children.length; i++) {
-        if (!spatialFilterCells.has(children[i]))
+      const intersection3 = intersectTileRaster(
+        parent,
+        cellResolution,
+        options.spatialFilter
+      );
+      if (intersection3 === false)
+        continue;
+      const tileSortedCells = cellToChildrenRaster(parent, cellResolution);
+      for (let i = 0; i < tileSortedCells.length; i++) {
+        if (intersection3 !== true && !intersection3.has(tileSortedCells[i])) {
           continue;
+        }
         const cellData = {};
         let cellDataExists = false;
         for (const band2 in tile.data.cells.numericProps) {
@@ -16687,7 +17739,7 @@ void main(void) {
           }
         }
         if (cellDataExists) {
-          data.set(children[i], cellData);
+          data.set(tileSortedCells[i], cellData);
         }
       }
     }
@@ -16699,17 +17751,19 @@ void main(void) {
   function isRasterTileVisible(tile) {
     return !!(tile.isVisible && tile.data?.cells?.numericProps);
   }
-  function cellToChildrenSorted(parent, resolution) {
-    return cellToChildren(parent, resolution).sort(
-      (cellA, cellB) => {
-        const tileA = cellToTile2(cellA);
-        const tileB = cellToTile2(cellB);
-        if (tileA.y !== tileB.y) {
-          return tileA.y > tileB.y ? 1 : -1;
-        }
-        return tileA.x > tileB.x ? 1 : -1;
-      }
-    );
+  function cellToChildrenRaster(parent, resolution) {
+    const parentTile = cellToTile2(parent);
+    const childZ = Number(resolution);
+    const blockSize = 2 ** (childZ - parentTile.z);
+    const childBaseX = parentTile.x * blockSize;
+    const childBaseY = parentTile.y * blockSize;
+    const cells = [];
+    for (let i = 0, il = blockSize ** 2; i < il; i++) {
+      const x = childBaseX + i % blockSize;
+      const y = childBaseY + Math.floor(i / blockSize);
+      cells.push(tileToCell2({ x, y, z: childZ }));
+    }
+    return cells;
   }
   function isValidBandValue(value, nodata) {
     return Number.isNaN(value) ? false : nodata !== value;
@@ -16897,7 +17951,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     headers: customHeaders = {},
     errorContext,
     maxLengthURL = DEFAULT_MAX_LENGTH_URL,
-    localCache
+    localCache,
+    signal
   }) {
     parameters = {
       v: V3_MINOR_VERSION,
@@ -16920,8 +17975,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     const fetchPromise = url.length > maxLengthURL ? fetch(baseUrl, {
       method: "POST",
       body: JSON.stringify(parameters),
-      headers
-    }) : fetch(url, { headers });
+      headers,
+      signal
+    }) : fetch(url, { headers, signal });
     let response;
     let responseJson;
     const jsonPromise = fetchPromise.then((_response) => {
@@ -16973,10 +18029,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       if (isPureObject(value) || Array.isArray(value)) {
         baseUrl.searchParams.set(key, JSON.stringify(value));
       } else {
-        baseUrl.searchParams.set(
-          key,
-          value.toString()
-        );
+        if (value !== null && value !== void 0) {
+          baseUrl.searchParams.set(
+            key,
+            value.toString()
+          );
+        }
       }
     }
     return baseUrl.toString();
@@ -17015,7 +18073,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       Authorization: `Bearer ${options.accessToken}`,
       ...options.headers
     };
-    const parameters = { client: clientId, ...urlParameters };
+    const parameters = { client: clientId, ...options.tags, ...urlParameters };
     const errorContext = {
       requestType: "Map instantiation",
       connection: options.connectionName,
@@ -17144,7 +18202,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     "timeseries",
     "range",
     "scatterplot",
-    "table"
+    "table",
+    "aggregations"
   ];
   var { V3 } = ApiVersion;
   var REQUEST_GET_MAX_URL_LENGTH = 2048;
@@ -17171,7 +18230,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       filtersLogicalOperator = "and",
       spatialDataType = "geo",
       spatialDataColumn = DEFAULT_GEO_COLUMN,
-      spatialFiltersMode = "intersects"
+      spatialFiltersMode = "intersects",
+      tags
     } = source;
     const queryParams = {
       type,
@@ -17180,7 +18240,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       params,
       queryParameters: source.queryParameters || "",
       filters,
-      filtersLogicalOperator
+      filtersLogicalOperator,
+      ...tags ?? {}
     };
     queryParams.spatialDataType = spatialDataType;
     queryParams.spatialDataColumn = spatialDataColumn;
@@ -17240,6 +18301,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
     return applicableFilters;
   }
+  var OTHERS_CATEGORY_NAME = "_carto_others";
   var WidgetRemoteSource = class extends WidgetSource {
     _getModelSource(filters, filterOwner) {
       const props = this.props;
@@ -17252,7 +18314,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         filters: getApplicableFilters(filterOwner, filters || props.filters),
         filtersLogicalOperator: props.filtersLogicalOperator,
         spatialDataType: props.spatialDataType,
-        spatialDataColumn: props.spatialDataColumn
+        spatialDataColumn: props.spatialDataColumn,
+        tags: props.tags
       };
     }
     async getCategories(options) {
@@ -17262,13 +18325,21 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         filterOwner,
         spatialFilter,
         spatialFiltersMode,
+        rawResult,
         ...params
       } = options;
-      const { column, operation: operation2, operationColumn, operationExp } = params;
+      const {
+        column,
+        operation: operation2,
+        operationColumn,
+        operationExp,
+        othersThreshold,
+        orderBy
+      } = params;
       if (operation2 === AggregationTypes.Custom) {
         assert22(operationExp, "operationExp is required for custom operation");
       }
-      return executeModel({
+      const result = await executeModel({
         model: "category",
         source: {
           ...this.getModelSource(filters, filterOwner),
@@ -17279,10 +18350,23 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           column,
           operation: operation2,
           operationExp,
-          operationColumn: operationColumn || column
+          operationColumn: operationColumn || column,
+          othersThreshold,
+          orderBy
         },
         opts: { signal, headers: this.props.headers }
-      }).then((res) => normalizeObjectKeys(res.rows));
+      });
+      const normalizedRows = normalizeObjectKeys(result.rows || []);
+      if (rawResult) {
+        return result;
+      }
+      if (!othersThreshold) {
+        return normalizedRows;
+      }
+      return [
+        ...normalizedRows,
+        { name: OTHERS_CATEGORY_NAME, value: result?.metadata?.others }
+      ];
     }
     async getFeatures(options) {
       const {
@@ -17500,6 +18584,72 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         categories: res.metadata?.categories
       }));
     }
+    async getAggregations(options) {
+      const {
+        signal,
+        filters = this.props.filters,
+        filterOwner,
+        spatialFilter,
+        spatialFiltersMode,
+        aggregations
+      } = options;
+      return executeModel({
+        model: "aggregations",
+        source: {
+          ...this.getModelSource(filters, filterOwner),
+          spatialFiltersMode,
+          spatialFilter
+        },
+        params: {
+          aggregations
+        },
+        opts: { signal, headers: this.props.headers }
+      }).then((res) => ({
+        rows: res.rows.map((row) => normalizeObjectKeys(row))
+      }));
+    }
+    /** @experimental */
+    async getExtent(options = {}) {
+      const { signal, filters = this.props.filters, filterOwner } = options;
+      const {
+        type,
+        data,
+        apiBaseUrl,
+        apiVersion,
+        connectionName,
+        spatialDataColumn,
+        spatialDataType,
+        queryParameters
+      } = this.getModelSource(filters, filterOwner);
+      assert22(apiVersion === "v3", "Stats API requires CARTO 3+");
+      let url;
+      const parameters = { filters, spatialDataType };
+      if (type === "query") {
+        url = `${apiBaseUrl}/${apiVersion}/stats/${connectionName}/${spatialDataColumn}`;
+        parameters.q = data;
+        parameters.queryParameters = queryParameters;
+      } else {
+        url = `${apiBaseUrl}/${apiVersion}/stats/${connectionName}/${data}/${spatialDataColumn}`;
+      }
+      const headers = {
+        Authorization: `Bearer ${this.props.accessToken}`,
+        ...this.props.headers
+      };
+      const errorContext = {
+        requestType: "Tile stats",
+        connection: connectionName,
+        type
+      };
+      return requestWithParameters({
+        baseUrl: url,
+        headers,
+        signal,
+        errorContext,
+        parameters
+      }).then(({ extent: { xmin, ymin, xmax, ymax } }) => ({
+        bbox: [xmin, ymin, xmax, ymax]
+      }));
+    }
   };
   var WidgetQuerySource = class extends WidgetRemoteSource {
     getModelSource(filters, filterOwner) {
@@ -17667,10 +18817,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     valuesColumns,
     joinOperation,
     keysColumn,
-    operation: operation2
+    operation: operation2,
+    othersThreshold,
+    orderBy = "frequency_desc"
   }) {
     if (Array.isArray(data) && data.length === 0) {
-      return null;
+      return { rows: null };
     }
     const groups = data.reduce((accumulator, item) => {
       const group2 = item[keysColumn];
@@ -17685,13 +18837,43 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       return accumulator;
     }, /* @__PURE__ */ new Map());
     const targetOperation = aggregationFunctions[operation2];
-    if (targetOperation) {
-      return Array.from(groups).map(([name, value]) => ({
-        name,
-        value: targetOperation(value)
-      }));
+    if (!targetOperation) {
+      return { rows: [] };
+    }
+    const allCategories = Array.from(groups).map(([name, value]) => ({
+      name,
+      value: targetOperation(value)
+    })).sort(getSorter(orderBy));
+    if (othersThreshold && allCategories.length > othersThreshold) {
+      const otherValue = allCategories.slice(othersThreshold).flatMap(({ name }) => groups.get(name));
+      return {
+        rows: allCategories,
+        metadata: {
+          others: targetOperation(otherValue)
+        }
+      };
+    }
+    return {
+      rows: allCategories
+    };
+  }
+  function getSorter(orderBy) {
+    switch (orderBy) {
+      case "frequency_asc":
+        return (a, b) => a.value - b.value || nameCompare(a.name, b.name);
+      case "frequency_desc":
+        return (a, b) => b.value - a.value || nameCompare(a.name, b.name);
+      case "alphabetical_asc":
+        return (a, b) => nameCompare(a.name, b.name) || b.value - a.value;
+      case "alphabetical_desc":
+        return (a, b) => nameCompare(b.name, a.name) || b.value - a.value;
+    }
+  }
+  function nameCompare(a, b) {
+    if (typeof a === "number" && typeof b === "number") {
+      return a - b;
     }
-    return [];
+    return String(a ?? "null").localeCompare(String(b ?? "null"));
   }
   function getUTCMonday(date) {
     const dateCp = new Date(date);
@@ -18155,7 +19337,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
     _extractTileFeatures(spatialFilter) {
       const prevInputs = this._tileFeatureExtractPreviousInputs;
-      if (this._features.length && prevInputs.spatialFilter && booleanEqual(prevInputs.spatialFilter, spatialFilter)) {
+      if (this._features.length && spatialFilterEquals(prevInputs.spatialFilter, spatialFilter)) {
         return;
       }
       this._features = tileFeatures({
@@ -18207,6 +19389,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         assertColumn(this._features, column);
       }
       const targetOperation = aggregationFunctions[operation2];
+      assert22(targetOperation, `Unsupported aggregation operation: ${operation2}`);
       return {
         value: targetOperation(filteredFeatures, column, joinOperation)
       };
@@ -18244,7 +19427,10 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       joinOperation,
       filters,
       filterOwner,
-      spatialFilter
+      spatialFilter,
+      othersThreshold,
+      orderBy = "frequency_desc",
+      rawResult
     }) {
       const filteredFeatures = this._getFilteredFeatures(
         spatialFilter,
@@ -18255,14 +19441,25 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         return [];
       }
       assertColumn(this._features, column, operationColumn);
-      const groups = groupValuesByColumn({
+      const result = groupValuesByColumn({
         data: filteredFeatures,
         valuesColumns: normalizeColumns(operationColumn || column),
         joinOperation,
         keysColumn: column,
-        operation: operation2
+        operation: operation2,
+        othersThreshold,
+        orderBy
       });
-      return groups || [];
+      if (rawResult) {
+        return result;
+      }
+      if (!othersThreshold) {
+        return result?.rows || [];
+      }
+      return [
+        ...result?.rows || [],
+        { name: OTHERS_CATEGORY_NAME, value: result?.metadata?.others }
+      ];
     }
     async getScatter({
       xAxisColumn,
@@ -18391,11 +19588,47 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         max: aggregationFunctions.max(filteredFeatures, column)
       };
     }
+    async getAggregations({
+      aggregations,
+      filters,
+      filterOwner,
+      spatialFilter
+    }) {
+      const filteredFeatures = this._getFilteredFeatures(
+        spatialFilter,
+        filters,
+        filterOwner
+      );
+      if (!this._features.length) {
+        return { rows: [] };
+      }
+      assert22(
+        typeof aggregations !== "string",
+        "Unsupported tileset SQL aggregation"
+      );
+      const result = {};
+      const usedAliases = /* @__PURE__ */ new Set();
+      for (const { column, operation: operation2, alias } of aggregations) {
+        if (column && column !== "*" || operation2 !== AggregationTypes.Count) {
+          assertColumn(this._features, column);
+        }
+        const aliasKey = alias.toLowerCase();
+        assert22(!usedAliases.has(aliasKey), `Duplicate alias: ${aliasKey}`);
+        usedAliases.add(aliasKey);
+        const targetOperation = aggregationFunctions[operation2];
+        assert22(targetOperation, `Unsupported operation: ${operation2}`);
+        result[alias] = targetOperation(filteredFeatures, column);
+      }
+      return { rows: [result] };
+    }
+    /** @experimental */
+    async getExtent() {
+      return Promise.reject(new Error("not implemented"));
+    }
     /****************************************************************************
      * INTERNAL
      */
     _getFilteredFeatures(spatialFilter, filters, filterOwner) {
-      assert22(spatialFilter, "spatialFilter required for tilesets");
       this._extractTileFeatures(spatialFilter);
       return applyFilters(
         this._features,
@@ -18419,6 +19652,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   function normalizeColumns(columns) {
     return Array.isArray(columns) ? columns : typeof columns === "string" ? [columns] : [];
   }
+  function spatialFilterEquals(a, b) {
+    if (a === b)
+      return true;
+    if (!a || !b)
+      return false;
+    return booleanEqual(a, b);
+  }
   var WidgetTilesetSource = class extends WidgetSource {
     constructor(props) {
       super(props);
@@ -18617,6 +19857,22 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }) {
       return this._executeWorkerMethod("getRange", [options], signal);
     }
+    async getAggregations({
+      signal,
+      ...options
+    }) {
+      return this._executeWorkerMethod(
+        "getAggregations",
+        [options],
+        signal
+      );
+    }
+    /** @experimental */
+    async getExtent() {
+      return Promise.resolve({
+        bbox: this.props.spatialDataBounds
+      });
+    }
   };
   var WidgetRasterSource = class extends WidgetTilesetSource {
   };
@@ -18711,25 +19967,6 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     const tileParams = new URL(tilejson.tiles[0]).searchParams;
     return tileParams.get("formatTiles") === "mvt" ? "mvt" : "binary";
   }
-  var rasterSource = async function(options) {
-    const { tableName, filters } = options;
-    const urlParameters = { name: tableName };
-    if (filters) {
-      urlParameters.filters = filters;
-    }
-    return baseSource("raster", options, urlParameters).then(
-      (result) => ({
-        ...result,
-        widgetSource: new WidgetRasterSource({
-          ...options,
-          tileFormat: getTileFormat(result),
-          spatialDataColumn: "quadbin",
-          spatialDataType: "quadbin",
-          rasterMetadata: result.raster_metadata
-        })
-      })
-    );
-  };
   var quadbinQuerySource = async function(options) {
     const {
       aggregationExp,
@@ -18808,6 +20045,26 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       })
     );
   };
+  var rasterSource = async function(options) {
+    const { tableName, filters } = options;
+    const urlParameters = { name: tableName };
+    if (filters) {
+      urlParameters.filters = filters;
+    }
+    return baseSource("raster", options, urlParameters).then(
+      (result) => ({
+        ...result,
+        widgetSource: new WidgetRasterSource({
+          ...options,
+          tileFormat: getTileFormat(result),
+          spatialDataColumn: "quadbin",
+          spatialDataType: "quadbin",
+          spatialDataBounds: result.bounds,
+          rasterMetadata: result.raster_metadata
+        })
+      })
+    );
+  };
   var vectorQuerySource = async function(options) {
     const {
       columns,
@@ -18898,7 +20155,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           ...options,
           tileFormat: getTileFormat(result),
           spatialDataColumn,
-          spatialDataType: "geo"
+          spatialDataType: "geo",
+          spatialDataBounds: result.bounds
         })
       })
     );
@@ -19007,14 +20265,188 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       );
     });
   }
-  var basemap_styles_default = {
-    VOYAGER: getStyleUrl("voyager"),
-    POSITRON: getStyleUrl("positron"),
-    DARK_MATTER: getStyleUrl("dark-matter"),
-    VOYAGER_NOLABELS: getStyleUrl("voyager-nolabels"),
-    POSITRON_NOLABELS: getStyleUrl("positron-nolabels"),
-    DARK_MATTER_NOLABELS: getStyleUrl("dark-matter-nolabels")
-  };
+  var basemap_styles_default = {
+    VOYAGER: getStyleUrl("voyager"),
+    POSITRON: getStyleUrl("positron"),
+    DARK_MATTER: getStyleUrl("dark-matter"),
+    VOYAGER_NOLABELS: getStyleUrl("voyager-nolabels"),
+    POSITRON_NOLABELS: getStyleUrl("positron-nolabels"),
+    DARK_MATTER_NOLABELS: getStyleUrl("dark-matter-nolabels")
+  };
+  function createVecExprEvaluator(expression) {
+    try {
+      const parsed = compile(expression);
+      const evalFun = (context) => evaluate(parsed, context);
+      evalFun.symbols = getSymbols(parsed);
+      return evalFun;
+    } catch {
+      return null;
+    }
+  }
+  function createResultArray(typeTemplate, length2 = typeTemplate.length) {
+    return new Array(length2);
+  }
+  function isVecLike(a) {
+    return Array.isArray(a) || ArrayBuffer.isView(a);
+  }
+  var createBinopVec = (scalarBinOp) => (left, right) => {
+    const length2 = Math.min(left.length, right.length);
+    const r = createResultArray(left, length2);
+    for (let i = 0; i < length2; i++) {
+      r[i] = scalarBinOp(left[i], right[i]);
+    }
+    return r;
+  };
+  var createBinopVecNum = (scalarBinOp) => (left, right) => {
+    const length2 = left.length;
+    const r = createResultArray(left, length2);
+    for (let i = 0; i < length2; i++) {
+      r[i] = scalarBinOp(left[i], right);
+    }
+    return r;
+  };
+  var createBinopNumVec = (scalarBinOp) => (left, right) => {
+    const length2 = right.length;
+    const r = createResultArray(right, length2);
+    for (let i = 0; i < length2; i++) {
+      r[i] = scalarBinOp(left, right[i]);
+    }
+    return r;
+  };
+  var createUnopVec = (scalarUnop) => (a) => {
+    const length2 = a.length;
+    const r = createResultArray(a, length2);
+    for (let i = 0; i < length2; i++) {
+      r[i] = scalarUnop(a[i]);
+    }
+    return r;
+  };
+  function mapDictValues(dict, fun) {
+    return Object.keys(dict).reduce(
+      (acc, key) => {
+        acc[key] = fun(dict[key]);
+        return acc;
+      },
+      {}
+    );
+  }
+  var binopsNum = {
+    "||": (a, b) => a || b,
+    "&&": (a, b) => a && b,
+    "|": (a, b) => a | b,
+    "^": (a, b) => a ^ b,
+    "&": (a, b) => a & b,
+    "==": (a, b) => Number(a == b),
+    "!=": (a, b) => Number(a != b),
+    "===": (a, b) => Number(a === b),
+    "!==": (a, b) => Number(a !== b),
+    "<": (a, b) => Number(a < b),
+    ">": (a, b) => Number(a > b),
+    "<=": (a, b) => Number(a <= b),
+    ">=": (a, b) => Number(a >= b),
+    "<<": (a, b) => a << b,
+    ">>": (a, b) => a >> b,
+    ">>>": (a, b) => a >>> b,
+    "+": (a, b) => a + b,
+    "-": (a, b) => a - b,
+    "*": (a, b) => a * b,
+    "/": (a, b) => a / b,
+    "%": (a, b) => a % b
+  };
+  var unopsNum = {
+    "-": (a) => -a,
+    "+": (a) => +a,
+    "~": (a) => ~a,
+    "!": (a) => Number(!a)
+  };
+  var binopsVector = mapDictValues(binopsNum, createBinopVec);
+  var binopsNumVec = mapDictValues(binopsNum, createBinopNumVec);
+  var binopsVecNum = mapDictValues(binopsNum, createBinopVecNum);
+  var unopsVector = mapDictValues(unopsNum, createUnopVec);
+  function getBinop(operator, left, right) {
+    const isLeftVec = isVecLike(left);
+    const isRightVec = isVecLike(right);
+    if (isLeftVec && isRightVec) {
+      return binopsVector[operator];
+    } else if (isLeftVec) {
+      return binopsVecNum[operator];
+    } else if (isRightVec) {
+      return binopsNumVec[operator];
+    } else {
+      return binopsNum[operator];
+    }
+  }
+  function evaluate(_node, context) {
+    const node = _node;
+    switch (node.type) {
+      case "BinaryExpression": {
+        const left = evaluate(node.left, context);
+        const right = evaluate(node.right, context);
+        const binopFun = getBinop(node.operator, left, right);
+        return binopFun(left, right);
+      }
+      case "ConditionalExpression": {
+        const val = evaluate(node.test, context);
+        if (isVecLike(val)) {
+          const length2 = val.length;
+          const consequentVal = evaluate(node.consequent, context);
+          const alternateVal = evaluate(node.alternate, context);
+          const r = createResultArray(val);
+          for (let i = 0; i < length2; i++) {
+            const entryVal = val[i] ? consequentVal : alternateVal;
+            r[i] = isVecLike(entryVal) ? entryVal[i] ?? NaN : entryVal;
+          }
+          return r;
+        } else {
+          return val ? evaluate(node.consequent, context) : evaluate(node.alternate, context);
+        }
+      }
+      case "Identifier":
+        return context[node.name];
+      case "Literal":
+        return node.value;
+      case "UnaryExpression": {
+        const val = evaluate(node.argument, context);
+        const unopFun = isVecLike(val) ? unopsVector[node.operator] : unopsNum[node.operator];
+        return unopFun(val);
+      }
+      default:
+        return void 0;
+    }
+  }
+  function visit(_node, visitor) {
+    const node = _node;
+    visitor(node);
+    switch (node.type) {
+      case "BinaryExpression": {
+        visit(node.left, visitor);
+        visit(node.right, visitor);
+        break;
+      }
+      case "ConditionalExpression": {
+        visit(node.test, visitor);
+        visit(node.consequent, visitor);
+        visit(node.alternate, visitor);
+        break;
+      }
+      case "UnaryExpression": {
+        visit(node.argument, visitor);
+        break;
+      }
+    }
+  }
+  function getSymbols(node) {
+    const symbols = /* @__PURE__ */ new Set();
+    visit(node, (node2) => {
+      if (node2.type === "Identifier") {
+        symbols.add(node2.name);
+      }
+    });
+    return Array.from(symbols);
+  }
+  function compile(expression) {
+    return jsep(expression);
+  }
   function define_default2(constructor, factory, prototype) {
     constructor.prototype = factory.prototype = prototype;
     prototype.constructor = constructor;
@@ -19434,6 +20866,37 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   function formatTimestamp(value) {
     return String(Math.floor(new Date(value).getTime() / 1e3));
   }
+  function roundedPow10(exp) {
+    const raw = Math.pow(10, exp);
+    if (exp < 0) {
+      const shift = Math.pow(10, -exp);
+      return Math.round(raw * shift) / shift;
+    }
+    return raw;
+  }
+  function getLog10ScaleSteps({
+    min: min2,
+    max: max2,
+    steps
+  }) {
+    if (min2 === 0) {
+      if (max2 === Infinity) {
+        return [...Array(steps - 1)].map((_v, i) => roundedPow10(i + 1));
+      }
+      const maxLog = Math.log10(max2);
+      const endExponent = Math.ceil(maxLog);
+      const startExponent = endExponent - steps + 1;
+      return [...Array(steps - 1)].map(
+        (_v, i) => roundedPow10(startExponent + i)
+      );
+    } else {
+      const minLog = Math.log10(min2);
+      const startExponent = Math.ceil(minLog) === minLog ? minLog + 1 : Math.ceil(minLog);
+      return [...Array(steps - 1)].map(
+        (_v, i) => roundedPow10(startExponent + i)
+      );
+    }
+  }
   var SCALE_FUNCS = {
     linear: linear2,
     ordinal,
@@ -19448,7 +20911,19 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   function identity2(v2) {
     return v2;
   }
+  var hexToRGB = (c) => {
+    const { r, g, b } = rgb2(c);
+    return [r, g, b];
+  };
+  var rgbToHex = (c) => {
+    const [r, g, b] = c;
+    const rStr = r.toString(16).padStart(2, "0");
+    const gStr = g.toString(16).padStart(2, "0");
+    const bStr = b.toString(16).padStart(2, "0");
+    return `#${rStr}${gStr}${bStr}`.toUpperCase();
+  };
   var UNKNOWN_COLOR = "#868d91";
+  var UNKNOWN_COLOR_RGB = hexToRGB(UNKNOWN_COLOR);
   var OPACITY_MAP = {
     getFillColor: "opacity",
     getLineColor: "strokeOpacity",
@@ -19481,6 +20956,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       wireframe: "wireframe"
     }
   };
+  var rasterPropsMap = {
+    isVisible: "visible",
+    visConfig: {
+      opacity: "opacity"
+    }
+  };
   var customMarkersPropsMap = {
     color: "getIconColor",
     visConfig: {
@@ -19524,6 +21005,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         `Outdated layer type: ${type}. Please open map in CARTO Builder to automatically migrate.`
       );
     }
+    if (type === "raster") {
+      return {
+        propMap: rasterPropsMap,
+        defaultProps: {}
+      };
+    }
     let basePropMap = sharedPropMap;
     if (config2.visConfig?.customMarkers) {
       basePropMap = mergePropMaps(basePropMap, customMarkersPropsMap);
@@ -19544,27 +21031,32 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
   function domainFromAttribute(attribute, scaleType, scaleLength) {
     if (scaleType === "ordinal" || scaleType === "point") {
+      if (!attribute.categories) {
+        return [0, 1];
+      }
       return attribute.categories.map((c) => c.category).filter((c) => c !== void 0 && c !== null);
     }
     if (scaleType === "quantile" && attribute.quantiles) {
-      return attribute.quantiles.global ? attribute.quantiles.global[scaleLength] : attribute.quantiles[scaleLength];
+      return "global" in attribute.quantiles ? attribute.quantiles.global[scaleLength] : attribute.quantiles[scaleLength];
     }
     let { min: min2 } = attribute;
     if (scaleType === "log" && min2 === 0) {
       min2 = 1e-5;
     }
-    return [min2, attribute.max];
+    return [min2 ?? 0, attribute.max ?? 1];
   }
   function calculateDomain(data, name, scaleType, scaleLength) {
     if (data.tilestats) {
       const { attributes } = data.tilestats.layers[0];
       const attribute = attributes.find((a) => a.attribute === name);
-      return domainFromAttribute(attribute, scaleType, scaleLength);
+      if (attribute) {
+        return domainFromAttribute(attribute, scaleType, scaleLength);
+      }
     }
     return [0, 1];
   }
   function normalizeAccessor(accessor, data) {
-    if (data.features || data.tilestats) {
+    if (data.features || data.tilestats || data.raster_metadata) {
       return (object, info) => {
         if (object) {
           return accessor(object.properties || object.__source.object.properties);
@@ -19597,46 +21089,72 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     return keys;
   }
   function getColorAccessor({ name, colorColumn }, scaleType, { aggregation, range: range2 }, opacity, data) {
-    const scale2 = calculateLayerScale(
+    const { scale: scale2, domain } = calculateLayerScale(
       colorColumn || name,
-      scaleType,
+      colorColumn ? "identity" : scaleType,
       range2,
       data
     );
     const alpha = opacityToAlpha(opacity);
-    let accessorKeys = getAccessorKeys(name, aggregation);
+    let accessorKeys = getAccessorKeys(colorColumn || name, aggregation);
     const accessor = (properties) => {
       if (!(accessorKeys[0] in properties)) {
         accessorKeys = findAccessorKey(accessorKeys, properties);
       }
       const propertyValue = properties[accessorKeys[0]];
-      const { r, g, b } = rgb2(scale2(propertyValue));
-      return [r, g, b, propertyValue === null ? 0 : alpha];
+      const scaled = scale2(propertyValue);
+      const rgb22 = typeof scaled === "string" ? hexToRGB(scaled) : scaled;
+      return [...rgb22, propertyValue === null ? 0 : alpha];
+    };
+    return {
+      accessor: normalizeAccessor(accessor, data),
+      scaleDomain: scale2.domain(),
+      domain,
+      range: (scale2.range() || []).map(rgbToHex)
     };
-    return { accessor: normalizeAccessor(accessor, data), scale: scale2 };
   }
   function calculateLayerScale(name, scaleType, range2, data) {
-    const scale2 = SCALE_FUNCS[scaleType]();
-    let domain = [];
-    let scaleColor = [];
+    let scaleDomain;
+    let scaleColors = [];
+    const { colors } = range2;
+    const domain = calculateDomain(data, name, scaleType, colors.length);
     if (scaleType !== "identity") {
-      const { colorMap, colors } = range2;
-      if (Array.isArray(colorMap)) {
+      if (range2.colorMap) {
+        const { colorMap } = range2;
+        scaleDomain = [];
         colorMap.forEach(([value, color22]) => {
-          domain.push(value);
-          scaleColor.push(color22);
+          scaleDomain.push(value);
+          scaleColors.push(color22);
         });
       } else {
-        domain = calculateDomain(data, name, scaleType, colors.length);
-        scaleColor = colors;
-      }
-      if (scaleType === "ordinal") {
-        domain = domain.slice(0, scaleColor.length);
+        if (scaleType === "custom" && range2.uiCustomScaleType === "logarithmic") {
+          const [min2, max2] = domain;
+          scaleDomain = getLog10ScaleSteps({
+            min: min2,
+            max: max2,
+            steps: colors.length
+          });
+          scaleColors = colors;
+        } else {
+          scaleColors = colors;
+        }
       }
     }
+    return {
+      scale: createColorScale(
+        scaleType,
+        scaleDomain || domain,
+        scaleColors.map(hexToRGB),
+        UNKNOWN_COLOR_RGB
+      ),
+      domain
+    };
+  }
+  function createColorScale(scaleType, domain, range2, unknown) {
+    const scale2 = SCALE_FUNCS[scaleType]();
     scale2.domain(domain);
-    scale2.range(scaleColor);
-    scale2.unknown(UNKNOWN_COLOR);
+    scale2.range(range2);
+    scale2.unknown(unknown);
     return scale2;
   }
   var FALLBACK_ICON = "data:image/svg+xml;charset=utf-8;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgcj0iNTAiLz4NCjwvc3ZnPg==";
@@ -19686,9 +21204,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
   function getSizeAccessor({ name }, scaleType, aggregation, range2, data) {
     const scale2 = scaleType ? SCALE_FUNCS[scaleType]() : identity2;
-    if (scaleType) {
+    let domain = [];
+    if (scaleType && range2) {
       if (aggregation !== AggregationTypes.Count) {
-        scale2.domain(calculateDomain(data, name, scaleType));
+        domain = calculateDomain(data, name, scaleType);
+        scale2.domain(domain);
+      } else {
+        domain = scale2.domain();
       }
       scale2.range(range2);
     }
@@ -19700,7 +21222,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       const propertyValue = properties[accessorKeys[0]];
       return scale2(propertyValue);
     };
-    return { accessor: normalizeAccessor(accessor, data), scale: scale2 };
+    return {
+      accessor: normalizeAccessor(accessor, data),
+      domain,
+      scaleDomain: domain,
+      range: range2
+    };
   }
   var FORMATS = {
     date: formatDate,
@@ -19757,12 +21284,399 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       return 11;
     return 11;
   }
+  var UNKNOWN_COLOR2 = [134, 141, 145];
+  var RASTER_COLOR_BANDS = ["red", "green", "blue"];
+  function getHasDataPredicate(noData) {
+    if (noData === "nan") {
+      return (v2) => !isNaN(v2);
+    }
+    if (typeof noData === "string") {
+      noData = parseFloat(noData);
+    }
+    if (typeof noData === "number") {
+      return (v2) => v2 !== noData && !isNaN(v2);
+    }
+    return () => true;
+  }
+  function createRasterColumnLayerDataTransform(transform) {
+    return (data) => {
+      if (!data || !("data" in data) || !data?.data?.cells?.numericProps) {
+        return data;
+      }
+      return transform(data);
+    };
+  }
+  function createEvaluationContext(numericProps, noData) {
+    const hasData = getHasDataPredicate(noData);
+    const bands = Object.entries(numericProps).map(([bandName, { value }]) => ({
+      bandName,
+      values: value,
+      copied: false
+    }));
+    const length2 = bands[0].values.length;
+    for (let i = 0; i < length2; i++) {
+      let hasSomeData = false;
+      for (let j = 0; j < bands.length; j++) {
+        hasSomeData = hasSomeData || hasData(bands[j].values[i]);
+      }
+      if (!hasSomeData) {
+        for (let j = 0; j < bands.length; j++) {
+          if (!bands[j].copied) {
+            bands[j].copied = true;
+            bands[j].values = Array.from(bands[j].values);
+          }
+          bands[j].values[i] = NaN;
+        }
+      }
+    }
+    const context = bands.reduce(
+      (agg, { bandName, values }) => {
+        agg[bandName] = values;
+        return agg;
+      },
+      {}
+    );
+    return context;
+  }
+  function createExprDataTransform({
+    colorBand,
+    rasterMetadata,
+    usedSymbols
+  }) {
+    if (!colorBand || !colorBand.type || colorBand.type === "none") {
+      return void 0;
+    }
+    const expr = colorBand?.type === "expression" ? colorBand.value : void 0;
+    const vecExprEvaluator = expr ? createVecExprEvaluator(expr) : void 0;
+    const dataTransform = createRasterColumnLayerDataTransform(
+      (dataWrapped) => {
+        const data = dataWrapped.data;
+        if (expr) {
+          const cachedResult = dataWrapped.customExpressionResults?.[expr];
+          if (cachedResult) {
+            return dataWrapped;
+          }
+        }
+        let context = dataWrapped.expressionEvalContext;
+        if (!context) {
+          const usedNumericProps = usedSymbols.reduce(
+            (acc, symbol) => {
+              acc[symbol] = data.cells.numericProps[symbol];
+              return acc;
+            },
+            {}
+          );
+          context = createEvaluationContext(
+            usedNumericProps,
+            rasterMetadata.nodata
+          );
+          dataWrapped = {
+            ...dataWrapped,
+            expressionEvalContext: context
+          };
+        }
+        if (!vecExprEvaluator || !expr)
+          return dataWrapped;
+        const evalResult = vecExprEvaluator(context);
+        return {
+          ...dataWrapped,
+          customExpressionResults: {
+            ...dataWrapped.customExpressionResults,
+            [expr]: evalResult
+          }
+        };
+      }
+    );
+    return dataTransform;
+  }
+  function combineDataTransforms(dataTransforms) {
+    const actualTransforms = dataTransforms.filter((v2) => v2);
+    if (actualTransforms.length === 0)
+      return void 0;
+    if (actualTransforms.length === 1)
+      return actualTransforms[0];
+    return (data) => actualTransforms.reduce(
+      (aggData, transformFun) => transformFun(aggData),
+      data
+    );
+  }
+  function createRgbToColorBufferDataTransform({
+    bandDefs,
+    attribute
+  }) {
+    return createRasterColumnLayerDataTransform(
+      (dataWrapped) => {
+        const length2 = dataWrapped.length;
+        const getBandBufferOrValue = (colorBand) => {
+          if (colorBand?.type === "expression") {
+            return dataWrapped.customExpressionResults?.[colorBand.value];
+          }
+          if (colorBand?.type === "band") {
+            return dataWrapped.expressionEvalContext?.[colorBand.value];
+          }
+          return 0;
+        };
+        const red = getBandBufferOrValue(bandDefs.red);
+        const green = getBandBufferOrValue(bandDefs.green);
+        const blue = getBandBufferOrValue(bandDefs.blue);
+        const colorBuffer = new Uint8Array(length2 * 4);
+        for (let inputIndex = 0, outputIndex = 0; inputIndex < length2; inputIndex++, outputIndex += 4) {
+          const redRaw = typeof red === "number" ? red : red ? red[inputIndex] : NaN;
+          const greenRaw = typeof green === "number" ? green : green ? green[inputIndex] : NaN;
+          const blueRaw = typeof blue === "number" ? blue : blue ? blue[inputIndex] : NaN;
+          if (isNaN(redRaw) && isNaN(greenRaw) && isNaN(blueRaw)) {
+            bufferSetRgba(colorBuffer, outputIndex, 0, 0, 0, 0);
+          } else {
+            bufferSetRgba(
+              colorBuffer,
+              outputIndex,
+              redRaw,
+              greenRaw,
+              blueRaw,
+              255
+            );
+          }
+        }
+        dataWrapped.customExpressionResults = void 0;
+        dataWrapped.expressionEvalContext = void 0;
+        return {
+          ...dataWrapped,
+          attributes: {
+            [attribute]: colorBuffer
+          }
+        };
+      }
+    );
+  }
+  function getUsedSymbols(colorBands) {
+    return Array.from(
+      colorBands.reduce((symbols, band2) => {
+        if (band2.type === "expression") {
+          const expressionSymbols = createVecExprEvaluator(band2.value)?.symbols || [];
+          expressionSymbols.forEach((symbol) => symbols.add(symbol));
+        }
+        if (band2.type === "band") {
+          symbols.add(band2.value);
+        }
+        return symbols;
+      }, /* @__PURE__ */ new Set())
+    );
+  }
+  function getRasterTileLayerStylePropsRgb({
+    layerConfig,
+    rasterMetadata,
+    visualChannels
+  }) {
+    const { visConfig } = layerConfig;
+    const { colorBands } = visConfig;
+    const bandDefs = {
+      red: colorBands?.find((band2) => band2.band === "red"),
+      green: colorBands?.find((band2) => band2.band === "green"),
+      blue: colorBands?.find((band2) => band2.band === "blue")
+    };
+    const rgbToInstanceFillColorsDataTransform = createRgbToColorBufferDataTransform({
+      bandDefs,
+      attribute: "instanceFillColors"
+    });
+    const usedSymbols = colorBands ? getUsedSymbols(colorBands) : [];
+    const bandTransforms = RASTER_COLOR_BANDS.map(
+      (band2) => createExprDataTransform({
+        colorBand: bandDefs[band2],
+        rasterMetadata,
+        usedSymbols
+      })
+    );
+    const combinedDataTransform = combineDataTransforms([
+      ...bandTransforms,
+      rgbToInstanceFillColorsDataTransform
+    ]);
+    return {
+      dataTransform: combinedDataTransform,
+      updateTriggers: getRasterTileLayerUpdateTriggers({
+        layerConfig,
+        visualChannels
+      })
+    };
+  }
+  function createBandColorScaleDataTransform({
+    bandName,
+    scaleFun,
+    nodata,
+    attribute
+  }) {
+    const hasData = getHasDataPredicate(nodata);
+    return createRasterColumnLayerDataTransform(
+      (dataWrapped) => {
+        const length2 = dataWrapped.length;
+        const bandBuffer = dataWrapped.data.cells.numericProps[bandName].value;
+        const colorBuffer = new Uint8Array(length2 * 4);
+        for (let i = 0; i < length2; i++) {
+          const rawValue = bandBuffer[i];
+          if (!hasData(rawValue)) {
+            bufferSetRgba(colorBuffer, i * 4, 0, 0, 0, 0);
+          } else {
+            const colorRgb = scaleFun(rawValue);
+            bufferSetRgba(
+              colorBuffer,
+              i * 4,
+              colorRgb[0],
+              colorRgb[1],
+              colorRgb[2],
+              255
+            );
+          }
+        }
+        return {
+          ...dataWrapped,
+          attributes: {
+            [attribute]: colorBuffer
+          }
+        };
+      }
+    );
+  }
+  function domainFromRasterMetadataBand(band2, scaleType, colorRange) {
+    if (scaleType === "ordinal") {
+      return colorRange.colorMap?.map(([value]) => value) || [];
+    }
+    if (scaleType === "custom") {
+      if (colorRange.uiCustomScaleType === "logarithmic") {
+        return getLog10ScaleSteps({
+          min: band2.stats.min,
+          max: band2.stats.max,
+          steps: colorRange.colors.length
+        });
+      } else {
+        return colorRange.colorMap?.map(([value]) => value) || [];
+      }
+    }
+    const scaleLength = colorRange.colors.length;
+    if (scaleType === "quantile") {
+      const quantiles = band2.stats.quantiles?.[scaleLength];
+      if (!quantiles) {
+        return [0, 1];
+      }
+      return [band2.stats.min, ...quantiles, band2.stats.max];
+    }
+    return [band2.stats.min, band2.stats.max];
+  }
+  function getRasterTileLayerStylePropsScaledBand({
+    layerConfig,
+    rasterMetadata,
+    visualChannels
+  }) {
+    const { visConfig } = layerConfig;
+    const { colorField } = visualChannels;
+    const { rasterStyleType } = visConfig;
+    const colorRange = rasterStyleType === "ColorRange" ? visConfig.colorRange : visConfig.uniqueValuesColorRange;
+    const scaleType = rasterStyleType === "ColorRange" ? visualChannels.colorScale : "ordinal";
+    const bandInfo = rasterMetadata.bands.find(
+      (band2) => band2.name === colorField?.name
+    );
+    if (!colorField?.name || !scaleType || !colorRange || !bandInfo) {
+      return {};
+    }
+    const domain = domainFromRasterMetadataBand(bandInfo, scaleType, colorRange);
+    const scaleFun = createColorScale(
+      scaleType,
+      domain,
+      colorRange.colors.map(hexToRGB2),
+      UNKNOWN_COLOR2
+    );
+    const bandColorScaleDataTransform = createBandColorScaleDataTransform({
+      bandName: bandInfo.name,
+      scaleFun,
+      nodata: bandInfo?.nodata ?? rasterMetadata.nodata,
+      attribute: "instanceFillColors"
+    });
+    return {
+      dataTransform: bandColorScaleDataTransform,
+      updateTriggers: getRasterTileLayerUpdateTriggers({
+        layerConfig,
+        visualChannels
+      })
+    };
+  }
+  function getRasterTileLayerUpdateTriggers({
+    layerConfig,
+    visualChannels
+  }) {
+    const { visConfig } = layerConfig;
+    const { rasterStyleType } = visConfig;
+    const getFillColorUpdateTriggers = {
+      rasterStyleType
+    };
+    if (rasterStyleType === "ColorRange") {
+      getFillColorUpdateTriggers.colorRange = visConfig.colorRange?.colors;
+      getFillColorUpdateTriggers.colorMap = visConfig.colorRange?.colorMap;
+      getFillColorUpdateTriggers.colorScale = visualChannels.colorScale;
+      getFillColorUpdateTriggers.colorFieldId = visualChannels.colorField?.name;
+    } else if (rasterStyleType === "UniqueValues") {
+      getFillColorUpdateTriggers.colorMap = visConfig.uniqueValuesColorRange?.colorMap;
+      getFillColorUpdateTriggers.colorFieldId = visualChannels.colorField?.name;
+    } else if (rasterStyleType === "Rgb") {
+      getFillColorUpdateTriggers.colorBands = visConfig.colorBands;
+    }
+    return {
+      getFillColor: getFillColorUpdateTriggers
+    };
+  }
+  function bufferSetRgba(target, index2, r, g, b, a) {
+    target[index2 + 0] = r;
+    target[index2 + 1] = g;
+    target[index2 + 2] = b;
+    target[index2 + 3] = a;
+  }
+  function hexToRGB2(hexColor) {
+    const r = parseInt(hexColor.slice(1, 3), 16);
+    const g = parseInt(hexColor.slice(3, 5), 16);
+    const b = parseInt(hexColor.slice(5, 7), 16);
+    return [r, g, b];
+  }
+  function getLayerDescriptor({
+    mapConfig,
+    layer,
+    dataset
+  }) {
+    const { filters, visState } = mapConfig;
+    const { layerBlending, interactionConfig } = visState;
+    const { id: id5, type, config: config2, visualChannels } = layer;
+    const { data, id: datasetId } = dataset;
+    const { propMap, defaultProps: defaultProps22 } = getLayerProps(type, config2, dataset);
+    const styleProps = createStyleProps(config2, propMap);
+    const { channelProps, scales } = createChannelProps(
+      id5,
+      type,
+      config2,
+      visualChannels,
+      data,
+      dataset
+    );
+    const layerDescriptor = {
+      type,
+      filters: isEmptyObject(filters) || isRemoteCalculationSupported(dataset) ? void 0 : filters[datasetId],
+      props: {
+        id: id5,
+        data,
+        ...defaultProps22,
+        ...createInteractionProps(interactionConfig),
+        ...styleProps,
+        ...channelProps,
+        ...createParametersProp(layerBlending, styleProps.parameters || {}),
+        // Must come after style
+        ...createLoadOptions(data.accessToken)
+      },
+      scales
+    };
+    return layerDescriptor;
+  }
   function parseMap(json) {
     const { keplerMapConfig, datasets, token } = json;
     assert22(keplerMapConfig.version === "v1", "Only support Kepler v1");
-    const config2 = keplerMapConfig.config;
-    const { filters, mapState, mapStyle, popupSettings, legendSettings } = config2;
-    const { layers, layerBlending, interactionConfig } = config2.visState;
+    const mapConfig = keplerMapConfig.config;
+    const { mapState, mapStyle, popupSettings, legendSettings, visState } = mapConfig;
+    const { layers } = visState;
+    const layersReverse = [...layers].reverse();
     return {
       id: json.id,
       title: json.title,
@@ -19775,45 +21689,19 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       popupSettings,
       legendSettings,
       token,
-      layers: layers.reverse().map(({ id: id5, type, config: config3, visualChannels }) => {
+      layers: layersReverse.map((layer) => {
         try {
-          const { dataId } = config3;
+          const { dataId } = layer.config;
           const dataset = datasets.find(
             (d) => d.id === dataId
           );
           assert22(dataset, `No dataset matching dataId: ${dataId}`);
-          const { data } = dataset;
-          assert22(data, `No data loaded for dataId: ${dataId}`);
-          const { propMap, defaultProps: defaultProps22 } = getLayerProps(type, config3, dataset);
-          const styleProps = createStyleProps(config3, propMap);
-          const { channelProps, scales } = createChannelProps(
-            id5,
-            type,
-            config3,
-            visualChannels,
-            data,
+          const layerDescriptor = getLayerDescriptor({
+            mapConfig,
+            layer,
             dataset
-          );
-          const layer = {
-            type,
-            filters: isEmptyObject(filters) || isRemoteCalculationSupported(dataset) ? void 0 : filters[dataId],
-            props: {
-              id: id5,
-              data,
-              ...defaultProps22,
-              ...createInteractionProps(interactionConfig),
-              ...styleProps,
-              ...channelProps,
-              ...createParametersProp(
-                layerBlending,
-                styleProps.parameters || {}
-              ),
-              // Must come after style
-              ...createLoadOptions(token)
-            },
-            scales
-          };
-          return layer;
+          });
+          return layerDescriptor;
         } catch (e) {
           console.error(e.message);
           return void 0;
@@ -19878,43 +21766,63 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     result.highlightColor = config2.visConfig.enable3d ? [255, 255, 255, 60] : [252, 242, 26, 255];
     return result;
   }
-  function domainAndRangeFromScale(scale2) {
-    return {
-      domain: scale2.domain(),
-      range: scale2.range()
-    };
-  }
   function createChannelProps(id5, layerType, config2, visualChannels, data, dataset) {
-    const {
-      colorField,
-      colorScale,
-      radiusField,
-      radiusScale,
-      strokeColorField,
-      strokeColorScale,
-      weightField
-    } = visualChannels;
-    const { heightField, heightScale } = visualChannels;
+    if (layerType === "raster") {
+      const rasterMetadata = data.raster_metadata;
+      if (!rasterMetadata) {
+        return {
+          channelProps: {},
+          scales: {}
+        };
+      }
+      const rasterStyleType = config2.visConfig.rasterStyleType;
+      if (rasterStyleType === "Rgb") {
+        return {
+          channelProps: getRasterTileLayerStylePropsRgb({
+            layerConfig: config2,
+            rasterMetadata,
+            visualChannels
+          }),
+          scales: {}
+          // TODO
+        };
+      } else {
+        return {
+          channelProps: getRasterTileLayerStylePropsScaledBand({
+            layerConfig: config2,
+            visualChannels,
+            rasterMetadata
+          }),
+          scales: {
+            // TODO
+          }
+        };
+      }
+    }
     const { textLabel, visConfig } = config2;
     const result = {};
+    const updateTriggers = {};
     const scales = {};
-    if (colorField) {
-      const { colorAggregation: aggregation, colorRange: range2 } = visConfig;
-      const { accessor, scale: scale2 } = getColorAccessor(
-        colorField,
-        colorScale,
-        { aggregation, range: range2 },
-        visConfig.opacity,
-        data
-      );
-      result.getFillColor = accessor;
-      scales.fillColor = {
-        field: colorField,
-        type: colorScale,
-        ...domainAndRangeFromScale(scale2)
-      };
-    } else if (visConfig.filled) {
-      scales.fillColor = {};
+    {
+      const { colorField, colorScale } = visualChannels;
+      const { colorRange, colorAggregation } = visConfig;
+      if (colorField && colorScale && colorRange) {
+        const { accessor, ...scaleProps } = getColorAccessor(
+          colorField,
+          colorScale,
+          { aggregation: colorAggregation, range: colorRange },
+          visConfig.opacity,
+          data
+        );
+        result.getFillColor = accessor;
+        scales.fillColor = updateTriggers.getFillColor = {
+          field: colorField,
+          type: colorScale,
+          ...scaleProps
+        };
+      } else {
+        scales.fillColor = {};
+      }
     }
     if (layerType === "clusterTile") {
       const aggregationExpAlias = getDefaultAggregationExpColumnAliasForLayerType(
@@ -19927,6 +21835,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       result.getWeight = (d) => {
         return d.properties[aggregationExpAlias];
       };
+      updateTriggers.getWeight = aggregationExpAlias;
       result.getPointRadius = (d, info) => {
         return calculateClusterRadius(
           d.properties,
@@ -19935,11 +21844,16 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           aggregationExpAlias
         );
       };
+      updateTriggers.getPointRadius = {
+        aggregationExpAlias,
+        radiusRange: visConfig.radiusRange
+      };
       result.textCharacterSet = "auto";
       result.textFontFamily = "Inter, sans";
       result.textFontSettings = { sdf: true };
       result.textFontWeight = 600;
       result.getText = (d) => TEXT_NUMBER_FORMATTER.format(d.properties[aggregationExpAlias]);
+      updateTriggers.getText = aggregationExpAlias;
       result.getTextColor = config2.textLabel[TEXT_LABEL_INDEX].color;
       result.textOutlineColor = [
         ...config2.textLabel[TEXT_LABEL_INDEX].outlineColor,
@@ -19956,68 +21870,107 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         );
         return calculateClusterTextFontSize(radius);
       };
-    }
-    if (radiusField) {
-      const { accessor, scale: scale2 } = getSizeAccessor(
-        radiusField,
-        radiusScale,
-        visConfig.sizeAggregation,
-        visConfig.radiusRange || visConfig.sizeRange,
-        data
-      );
-      result.getPointRadius = accessor;
-      scales.pointRadius = {
-        field: radiusField,
-        type: radiusScale || "identity",
-        ...domainAndRangeFromScale(scale2)
+      updateTriggers.getTextSize = {
+        aggregationExpAlias,
+        radiusRange: visConfig.radiusRange
       };
     }
-    if (strokeColorField) {
-      const opacity = visConfig.strokeOpacity !== void 0 ? visConfig.strokeOpacity : 1;
-      const { strokeColorAggregation: aggregation, strokeColorRange: range2 } = visConfig;
-      const { accessor, scale: scale2 } = getColorAccessor(
-        strokeColorField,
-        strokeColorScale,
-        { aggregation, range: range2 },
-        opacity,
-        data
-      );
-      result.getLineColor = accessor;
-      scales.lineColor = {
-        field: strokeColorField,
-        type: strokeColorScale,
-        ...domainAndRangeFromScale(scale2)
-      };
+    {
+      const radiusRange = visConfig.radiusRange;
+      const { radiusField, radiusScale } = visualChannels;
+      if (radiusField && radiusRange && radiusScale) {
+        const { accessor, ...scaleProps } = getSizeAccessor(
+          radiusField,
+          radiusScale,
+          visConfig.radiusAggregation,
+          radiusRange,
+          data
+        );
+        result.getPointRadius = accessor;
+        scales.pointRadius = updateTriggers.getPointRadius = {
+          field: radiusField,
+          type: radiusScale,
+          ...scaleProps
+        };
+      }
     }
-    if (heightField && visConfig.enable3d) {
-      const { accessor, scale: scale2 } = getSizeAccessor(
-        heightField,
-        heightScale,
-        visConfig.heightAggregation,
-        visConfig.heightRange || visConfig.sizeRange,
-        data
-      );
-      result.getElevation = accessor;
-      scales.elevation = {
-        field: heightField,
-        type: heightScale || "identity",
-        ...domainAndRangeFromScale(scale2)
-      };
+    {
+      const strokeColorRange = visConfig.strokeColorRange;
+      const { strokeColorScale, strokeColorField } = visualChannels;
+      if (strokeColorField && strokeColorRange && strokeColorScale) {
+        const { strokeColorAggregation: aggregation } = visConfig;
+        const opacity = visConfig.strokeOpacity !== void 0 ? visConfig.strokeOpacity : 1;
+        const { accessor, ...scaleProps } = getColorAccessor(
+          strokeColorField,
+          strokeColorScale,
+          { aggregation, range: strokeColorRange },
+          opacity,
+          data
+        );
+        result.getLineColor = accessor;
+        scales.lineColor = updateTriggers.getLineColor = {
+          field: strokeColorField,
+          type: strokeColorScale,
+          ...scaleProps
+        };
+      }
     }
-    if (weightField) {
-      const { accessor, scale: scale2 } = getSizeAccessor(
-        weightField,
-        void 0,
-        visConfig.weightAggregation,
-        void 0,
-        data
-      );
-      result.getWeight = accessor;
-      scales.weight = {
-        field: weightField,
-        type: "identity",
-        ...domainAndRangeFromScale(scale2)
-      };
+    {
+      const { sizeField: strokeWidthField, sizeScale: strokeWidthScale } = visualChannels;
+      const { sizeRange, sizeAggregation } = visConfig;
+      if (strokeWidthField && sizeRange) {
+        const { accessor, ...scaleProps } = getSizeAccessor(
+          strokeWidthField,
+          strokeWidthScale,
+          sizeAggregation,
+          sizeRange,
+          data
+        );
+        result.getLineWidth = accessor;
+        scales.lineWidth = updateTriggers.getLineWidth = {
+          field: strokeWidthField,
+          type: strokeWidthScale || "identity",
+          ...scaleProps
+        };
+      }
+    }
+    {
+      const { enable3d, heightRange } = visConfig;
+      const { heightField, heightScale } = visualChannels;
+      if (heightField && heightRange && enable3d) {
+        const { accessor, ...scaleProps } = getSizeAccessor(
+          heightField,
+          heightScale,
+          visConfig.heightAggregation,
+          heightRange,
+          data
+        );
+        result.getElevation = accessor;
+        scales.elevation = updateTriggers.getElevation = {
+          field: heightField,
+          type: heightScale || "identity",
+          ...scaleProps
+        };
+      }
+    }
+    {
+      const { weightField } = visualChannels;
+      const { weightAggregation } = visConfig;
+      if (weightField && weightAggregation) {
+        const { accessor, ...scaleProps } = getSizeAccessor(
+          weightField,
+          void 0,
+          weightAggregation,
+          void 0,
+          data
+        );
+        result.getWeight = accessor;
+        scales.weight = updateTriggers.getWeight = {
+          field: weightField,
+          type: "identity",
+          ...scaleProps
+        };
+      }
     }
     if (visConfig.customMarkers) {
       const maxIconSize = getMaxMarkerSize(visConfig, visualChannels);
@@ -20034,6 +21987,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         { fallbackUrl: customMarkersUrl, maxIconSize, useMaskedIcons },
         data
       );
+      updateTriggers.getIcon = {
+        customMarkersUrl,
+        customMarkersRange,
+        maxIconSize,
+        useMaskedIcons
+      };
       result._subLayerProps = {
         "points-icon": {
           loadOptions: {
@@ -20050,9 +22009,11 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       };
       if (getFillColor && useMaskedIcons) {
         result.getIconColor = getFillColor;
+        updateTriggers.getIconColor = updateTriggers.getFillColor;
       }
       if (getPointRadius) {
         result.getIconSize = getPointRadius;
+        updateTriggers.getIconSize = updateTriggers.getPointRadius;
       }
       if (visualChannels.rotationField) {
         const { accessor } = getSizeAccessor(
@@ -20063,6 +22024,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           data
         );
         result.getIconAngle = negateAccessor(accessor);
+        updateTriggers.getIconAngle = updateTriggers.getRotationField;
       }
     } else if (layerType === "tileset") {
       result.pointType = "circle";
@@ -20107,7 +22069,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         }
       };
     }
-    return { channelProps: result, scales };
+    return {
+      channelProps: {
+        ...result,
+        updateTriggers
+      },
+      scales
+    };
   }
   function createLoadOptions(accessToken) {
     return {
@@ -20530,6 +22498,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
     return out;
   }
+  var EMPTY_U32 = 2 ** 32 - 1;
 
   // src/basemap.ts
   var cartoStyleUrlTemplate2 = "https://basemaps.cartocdn.com/gl/{basemap}-gl-style/style.json";