@carto/api-client 0.5.0-alpha.1 → 0.5.0-alpha.11

package/build/api-client.js

@@ -0,0 +1,3674 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __commonJS = (cb, mod2) => function __require() {
+  return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
+  mod2
+));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// node_modules/tilebelt/index.js
+var require_tilebelt = __commonJS({
+  "node_modules/tilebelt/index.js"(exports, module) {
+    "use strict";
+    var d2r = Math.PI / 180;
+    var r2d = 180 / Math.PI;
+    function tileToBBOX(tile) {
+      var e = tile2lon(tile[0] + 1, tile[2]);
+      var w = tile2lon(tile[0], tile[2]);
+      var s = tile2lat(tile[1] + 1, tile[2]);
+      var n = tile2lat(tile[1], tile[2]);
+      return [w, s, e, n];
+    }
+    function tileToGeoJSON(tile) {
+      var bbox = tileToBBOX(tile);
+      var poly = {
+        type: "Polygon",
+        coordinates: [
+          [
+            [bbox[0], bbox[1]],
+            [bbox[0], bbox[3]],
+            [bbox[2], bbox[3]],
+            [bbox[2], bbox[1]],
+            [bbox[0], bbox[1]]
+          ]
+        ]
+      };
+      return poly;
+    }
+    function tile2lon(x, z) {
+      return x / Math.pow(2, z) * 360 - 180;
+    }
+    function tile2lat(y, z) {
+      var n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);
+      return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
+    }
+    function pointToTile(lon, lat, z) {
+      var tile = pointToTileFraction(lon, lat, z);
+      tile[0] = Math.floor(tile[0]);
+      tile[1] = Math.floor(tile[1]);
+      return tile;
+    }
+    function getChildren(tile) {
+      return [
+        [tile[0] * 2, tile[1] * 2, tile[2] + 1],
+        [tile[0] * 2 + 1, tile[1] * 2, tile[2] + 1],
+        [tile[0] * 2 + 1, tile[1] * 2 + 1, tile[2] + 1],
+        [tile[0] * 2, tile[1] * 2 + 1, tile[2] + 1]
+      ];
+    }
+    function getParent(tile) {
+      if (tile[0] % 2 === 0 && tile[1] % 2 === 0) {
+        return [tile[0] / 2, tile[1] / 2, tile[2] - 1];
+      } else if (tile[0] % 2 === 0 && !tile[1] % 2 === 0) {
+        return [tile[0] / 2, (tile[1] - 1) / 2, tile[2] - 1];
+      } else if (!tile[0] % 2 === 0 && tile[1] % 2 === 0) {
+        return [(tile[0] - 1) / 2, tile[1] / 2, tile[2] - 1];
+      } else {
+        return [(tile[0] - 1) / 2, (tile[1] - 1) / 2, tile[2] - 1];
+      }
+    }
+    function getSiblings(tile) {
+      return getChildren(getParent(tile));
+    }
+    function hasSiblings(tile, tiles2) {
+      var siblings = getSiblings(tile);
+      for (var i = 0; i < siblings.length; i++) {
+        if (!hasTile(tiles2, siblings[i])) return false;
+      }
+      return true;
+    }
+    function hasTile(tiles2, tile) {
+      for (var i = 0; i < tiles2.length; i++) {
+        if (tilesEqual(tiles2[i], tile)) return true;
+      }
+      return false;
+    }
+    function tilesEqual(tile1, tile2) {
+      return tile1[0] === tile2[0] && tile1[1] === tile2[1] && tile1[2] === tile2[2];
+    }
+    function tileToQuadkey(tile) {
+      var index = "";
+      for (var z = tile[2]; z > 0; z--) {
+        var b = 0;
+        var mask = 1 << z - 1;
+        if ((tile[0] & mask) !== 0) b++;
+        if ((tile[1] & mask) !== 0) b += 2;
+        index += b.toString();
+      }
+      return index;
+    }
+    function quadkeyToTile(quadkey) {
+      var x = 0;
+      var y = 0;
+      var z = quadkey.length;
+      for (var i = z; i > 0; i--) {
+        var mask = 1 << i - 1;
+        switch (quadkey[z - i]) {
+          case "0":
+            break;
+          case "1":
+            x |= mask;
+            break;
+          case "2":
+            y |= mask;
+            break;
+          case "3":
+            x |= mask;
+            y |= mask;
+            break;
+        }
+      }
+      return [x, y, z];
+    }
+    function bboxToTile(bboxCoords) {
+      var min2 = pointToTile(bboxCoords[0], bboxCoords[1], 32);
+      var max2 = pointToTile(bboxCoords[2], bboxCoords[3], 32);
+      var bbox = [min2[0], min2[1], max2[0], max2[1]];
+      var z = getBboxZoom(bbox);
+      if (z === 0) return [0, 0, 0];
+      var x = bbox[0] >>> 32 - z;
+      var y = bbox[1] >>> 32 - z;
+      return [x, y, z];
+    }
+    function getBboxZoom(bbox) {
+      var MAX_ZOOM = 28;
+      for (var z = 0; z < MAX_ZOOM; z++) {
+        var mask = 1 << 32 - (z + 1);
+        if ((bbox[0] & mask) != (bbox[2] & mask) || (bbox[1] & mask) != (bbox[3] & mask)) {
+          return z;
+        }
+      }
+      return MAX_ZOOM;
+    }
+    function pointToTileFraction(lon, lat, z) {
+      var sin2 = Math.sin(lat * d2r), z2 = Math.pow(2, z), x = z2 * (lon / 360 + 0.5), y = z2 * (0.5 - 0.25 * Math.log((1 + sin2) / (1 - sin2)) / Math.PI);
+      return [x, y, z];
+    }
+    module.exports = {
+      tileToGeoJSON,
+      tileToBBOX,
+      getChildren,
+      getParent,
+      getSiblings,
+      hasTile,
+      hasSiblings,
+      tilesEqual,
+      tileToQuadkey,
+      quadkeyToTile,
+      pointToTile,
+      bboxToTile,
+      pointToTileFraction
+    };
+  }
+});
+
+// node_modules/@mapbox/tile-cover/index.js
+var require_tile_cover = __commonJS({
+  "node_modules/@mapbox/tile-cover/index.js"(exports) {
+    "use strict";
+    var tilebelt = require_tilebelt();
+    exports.geojson = function(geom, limits) {
+      return {
+        type: "FeatureCollection",
+        features: getTiles(geom, limits).map(tileToFeature)
+      };
+    };
+    function tileToFeature(t) {
+      return {
+        type: "Feature",
+        geometry: tilebelt.tileToGeoJSON(t),
+        properties: {}
+      };
+    }
+    exports.tiles = getTiles;
+    exports.indexes = function(geom, limits) {
+      return getTiles(geom, limits).map(tilebelt.tileToQuadkey);
+    };
+    function getTiles(geom, limits) {
+      var i, tile, coords = geom.coordinates, maxZoom = limits.max_zoom, tileHash = {}, tiles2 = [];
+      if (geom.type === "Point") {
+        return [tilebelt.pointToTile(coords[0], coords[1], maxZoom)];
+      } else if (geom.type === "MultiPoint") {
+        for (i = 0; i < coords.length; i++) {
+          tile = tilebelt.pointToTile(coords[i][0], coords[i][1], maxZoom);
+          tileHash[toID(tile[0], tile[1], tile[2])] = true;
+        }
+      } else if (geom.type === "LineString") {
+        lineCover(tileHash, coords, maxZoom);
+      } else if (geom.type === "MultiLineString") {
+        for (i = 0; i < coords.length; i++) {
+          lineCover(tileHash, coords[i], maxZoom);
+        }
+      } else if (geom.type === "Polygon") {
+        polygonCover(tileHash, tiles2, coords, maxZoom);
+      } else if (geom.type === "MultiPolygon") {
+        for (i = 0; i < coords.length; i++) {
+          polygonCover(tileHash, tiles2, coords[i], maxZoom);
+        }
+      } else {
+        throw new Error("Geometry type not implemented");
+      }
+      if (limits.min_zoom !== maxZoom) {
+        var len = tiles2.length;
+        appendHashTiles(tileHash, tiles2);
+        for (i = 0; i < len; i++) {
+          var t = tiles2[i];
+          tileHash[toID(t[0], t[1], t[2])] = true;
+        }
+        return mergeTiles(tileHash, tiles2, limits);
+      }
+      appendHashTiles(tileHash, tiles2);
+      return tiles2;
+    }
+    function mergeTiles(tileHash, tiles2, limits) {
+      var mergedTiles = [];
+      for (var z = limits.max_zoom; z > limits.min_zoom; z--) {
+        var parentTileHash = {};
+        var parentTiles = [];
+        for (var i = 0; i < tiles2.length; i++) {
+          var t = tiles2[i];
+          if (t[0] % 2 === 0 && t[1] % 2 === 0) {
+            var id2 = toID(t[0] + 1, t[1], z), id3 = toID(t[0], t[1] + 1, z), id4 = toID(t[0] + 1, t[1] + 1, z);
+            if (tileHash[id2] && tileHash[id3] && tileHash[id4]) {
+              tileHash[toID(t[0], t[1], t[2])] = false;
+              tileHash[id2] = false;
+              tileHash[id3] = false;
+              tileHash[id4] = false;
+              var parentTile = [t[0] / 2, t[1] / 2, z - 1];
+              if (z - 1 === limits.min_zoom) mergedTiles.push(parentTile);
+              else {
+                parentTileHash[toID(t[0] / 2, t[1] / 2, z - 1)] = true;
+                parentTiles.push(parentTile);
+              }
+            }
+          }
+        }
+        for (i = 0; i < tiles2.length; i++) {
+          t = tiles2[i];
+          if (tileHash[toID(t[0], t[1], t[2])]) mergedTiles.push(t);
+        }
+        tileHash = parentTileHash;
+        tiles2 = parentTiles;
+      }
+      return mergedTiles;
+    }
+    function polygonCover(tileHash, tileArray, geom, zoom) {
+      var intersections = [];
+      for (var i = 0; i < geom.length; i++) {
+        var ring = [];
+        lineCover(tileHash, geom[i], zoom, ring);
+        for (var j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
+          var m = (j + 1) % len;
+          var y = ring[j][1];
+          if ((y > ring[k][1] || y > ring[m][1]) && // not local minimum
+          (y < ring[k][1] || y < ring[m][1]) && // not local maximum
+          y !== ring[m][1]) intersections.push(ring[j]);
+        }
+      }
+      intersections.sort(compareTiles);
+      for (i = 0; i < intersections.length; i += 2) {
+        y = intersections[i][1];
+        for (var x = intersections[i][0] + 1; x < intersections[i + 1][0]; x++) {
+          var id = toID(x, y, zoom);
+          if (!tileHash[id]) {
+            tileArray.push([x, y, zoom]);
+          }
+        }
+      }
+    }
+    function compareTiles(a, b) {
+      return a[1] - b[1] || a[0] - b[0];
+    }
+    function lineCover(tileHash, coords, maxZoom, ring) {
+      var prevX, prevY;
+      for (var i = 0; i < coords.length - 1; i++) {
+        var start = tilebelt.pointToTileFraction(coords[i][0], coords[i][1], maxZoom), stop = tilebelt.pointToTileFraction(coords[i + 1][0], coords[i + 1][1], maxZoom), x0 = start[0], y0 = start[1], x1 = stop[0], y1 = stop[1], dx = x1 - x0, dy = y1 - y0;
+        if (dy === 0 && dx === 0) continue;
+        var sx = dx > 0 ? 1 : -1, sy = dy > 0 ? 1 : -1, x = Math.floor(x0), y = Math.floor(y0), tMaxX = dx === 0 ? Infinity : Math.abs(((dx > 0 ? 1 : 0) + x - x0) / dx), tMaxY = dy === 0 ? Infinity : Math.abs(((dy > 0 ? 1 : 0) + y - y0) / dy), tdx = Math.abs(sx / dx), tdy = Math.abs(sy / dy);
+        if (x !== prevX || y !== prevY) {
+          tileHash[toID(x, y, maxZoom)] = true;
+          if (ring && y !== prevY) ring.push([x, y]);
+          prevX = x;
+          prevY = y;
+        }
+        while (tMaxX < 1 || tMaxY < 1) {
+          if (tMaxX < tMaxY) {
+            tMaxX += tdx;
+            x += sx;
+          } else {
+            tMaxY += tdy;
+            y += sy;
+          }
+          tileHash[toID(x, y, maxZoom)] = true;
+          if (ring && y !== prevY) ring.push([x, y]);
+          prevX = x;
+          prevY = y;
+        }
+      }
+      if (ring && y === ring[0][1]) ring.pop();
+    }
+    function appendHashTiles(hash, tiles2) {
+      var keys = Object.keys(hash);
+      for (var i = 0; i < keys.length; i++) {
+        tiles2.push(fromID(+keys[i]));
+      }
+    }
+    function toID(x, y, z) {
+      var dim = 2 * (1 << z);
+      return (dim * y + x) * 32 + z;
+    }
+    function fromID(id) {
+      var z = id % 32, dim = 2 * (1 << z), xy = (id - z) / 32, x = xy % dim, y = (xy - x) / dim % dim;
+      return [x, y, z];
+    }
+  }
+});
+
+// node_modules/thenby/thenBy.module.js
+var require_thenBy_module = __commonJS({
+  "node_modules/thenby/thenBy.module.js"(exports, module) {
+    "use strict";
+    module.exports = function() {
+      function identity(v) {
+        return v;
+      }
+      function ignoreCase(v) {
+        return typeof v === "string" ? v.toLowerCase() : v;
+      }
+      function makeCompareFunction(f, opt) {
+        opt = typeof opt === "object" ? opt : { direction: opt };
+        if (typeof f != "function") {
+          var prop = f;
+          f = function(v1) {
+            return !!v1[prop] ? v1[prop] : "";
+          };
+        }
+        if (f.length === 1) {
+          var uf = f;
+          var preprocess = opt.ignoreCase ? ignoreCase : identity;
+          var cmp = opt.cmp || function(v1, v2) {
+            return v1 < v2 ? -1 : v1 > v2 ? 1 : 0;
+          };
+          f = function(v1, v2) {
+            return cmp(preprocess(uf(v1)), preprocess(uf(v2)));
+          };
+        }
+        const descTokens = { "-1": "", desc: "" };
+        if (opt.direction in descTokens) return function(v1, v2) {
+          return -f(v1, v2);
+        };
+        return f;
+      }
+      function tb(func, opt) {
+        var x = typeof this == "function" && !this.firstBy ? this : false;
+        var y = makeCompareFunction(func, opt);
+        var f = x ? function(a, b) {
+          return x(a, b) || y(a, b);
+        } : y;
+        f.thenBy = tb;
+        return f;
+      }
+      tb.firstBy = tb;
+      return tb;
+    }();
+  }
+});
+
+// src/client.ts
+var client = "deck-gl-carto";
+function getClient() {
+  return client;
+}
+function setClient(c) {
+  client = c;
+}
+
+// src/constants.ts
+var FilterType = /* @__PURE__ */ ((FilterType2) => {
+  FilterType2["IN"] = "in";
+  FilterType2["BETWEEN"] = "between";
+  FilterType2["CLOSED_OPEN"] = "closed_open";
+  FilterType2["TIME"] = "time";
+  FilterType2["STRING_SEARCH"] = "stringSearch";
+  return FilterType2;
+})(FilterType || {});
+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 TileFormat = /* @__PURE__ */ ((TileFormat2) => {
+  TileFormat2["MVT"] = "mvt";
+  TileFormat2["JSON"] = "json";
+  TileFormat2["GEOJSON"] = "geojson";
+  TileFormat2["BINARY"] = "binary";
+  return TileFormat2;
+})(TileFormat || {});
+var SpatialIndex = /* @__PURE__ */ ((SpatialIndex2) => {
+  SpatialIndex2["H3"] = "h3";
+  SpatialIndex2["S2"] = "s2";
+  SpatialIndex2["QUADBIN"] = "quadbin";
+  return SpatialIndex2;
+})(SpatialIndex || {});
+var Provider = /* @__PURE__ */ ((Provider2) => {
+  Provider2["BIGQUERY"] = "bigquery";
+  Provider2["REDSHIFT"] = "redshift";
+  Provider2["POSTGRES"] = "postgres";
+  Provider2["SNOWFLAKE"] = "snowflake";
+  Provider2["DATABRICKS"] = "databricks";
+  Provider2["DATABRICKS_REST"] = "databricksRest";
+  return Provider2;
+})(Provider || {});
+
+// src/utils/makeIntervalComplete.ts
+function makeIntervalComplete(intervals) {
+  return intervals.map((val) => {
+    if (val[0] === void 0 || val[0] === null) {
+      return [Number.MIN_SAFE_INTEGER, val[1]];
+    }
+    if (val[1] === void 0 || val[1] === null) {
+      return [val[0], Number.MAX_SAFE_INTEGER];
+    }
+    return val;
+  });
+}
+
+// src/filters/FilterTypes.ts
+var filterFunctions = {
+  ["in" /* IN */]: filterIn,
+  ["between" /* BETWEEN */]: filterBetween,
+  ["time" /* TIME */]: filterTime,
+  ["closed_open" /* CLOSED_OPEN */]: filterClosedOpen,
+  ["stringSearch" /* STRING_SEARCH */]: filterStringSearch
+};
+function filterIn(filterValues, featureValue) {
+  return filterValues.includes(featureValue);
+}
+function filterBetween(filterValues, featureValue) {
+  const checkRange = (range) => {
+    const [lowerBound, upperBound] = range;
+    return featureValue >= lowerBound && featureValue <= upperBound;
+  };
+  return makeIntervalComplete(filterValues).some(
+    checkRange
+  );
+}
+function filterTime(filterValues, featureValue) {
+  const featureValueAsTimestamp = new Date(featureValue).getTime();
+  if (isFinite(featureValueAsTimestamp)) {
+    return filterBetween(filterValues, featureValueAsTimestamp);
+  } else {
+    throw new Error(`Column used to filter by time isn't well formatted.`);
+  }
+}
+function filterClosedOpen(filterValues, featureValue) {
+  const checkRange = (range) => {
+    const [lowerBound, upperBound] = range;
+    return featureValue >= lowerBound && featureValue < upperBound;
+  };
+  return makeIntervalComplete(filterValues).some(
+    checkRange
+  );
+}
+function filterStringSearch(filterValues, featureValue, params = {}) {
+  const normalizedFeatureValue = normalize(featureValue, params);
+  const stringRegExp = params.useRegExp ? filterValues : filterValues.map((filterValue) => {
+    let stringRegExp2 = escapeRegExp(normalize(filterValue, params));
+    if (params.mustStart) stringRegExp2 = `^${stringRegExp2}`;
+    if (params.mustEnd) stringRegExp2 = `${stringRegExp2}$`;
+    return stringRegExp2;
+  });
+  const regex = new RegExp(
+    stringRegExp.join("|"),
+    params.caseSensitive ? "g" : "gi"
+  );
+  return !!normalizedFeatureValue.match(regex);
+}
+var specialCharRegExp = /[.*+?^${}()|[\]\\]/g;
+var normalizeRegExp = /\p{Diacritic}/gu;
+function escapeRegExp(value) {
+  return value.replace(specialCharRegExp, "\\$&");
+}
+function normalize(data, params) {
+  let normalizedData = String(data);
+  if (!params.keepSpecialCharacters)
+    normalizedData = normalizedData.normalize("NFD").replace(normalizeRegExp, "");
+  return normalizedData;
+}
+
+// src/filters/Filter.ts
+var LOGICAL_OPERATOR_METHODS = {
+  and: "every",
+  or: "some"
+};
+function passesFilter(columns, filters, feature2, filtersLogicalOperator) {
+  const method = LOGICAL_OPERATOR_METHODS[filtersLogicalOperator];
+  return columns[method]((column) => {
+    const columnFilters = filters[column];
+    const columnFilterTypes = Object.keys(columnFilters);
+    if (!feature2 || feature2[column] === null || feature2[column] === void 0) {
+      return false;
+    }
+    return columnFilterTypes.every((filter) => {
+      const filterFunction = filterFunctions[filter];
+      if (!filterFunction) {
+        throw new Error(`"${filter}" filter is not implemented.`);
+      }
+      return filterFunction(
+        columnFilters[filter].values,
+        feature2[column],
+        columnFilters[filter].params
+      );
+    });
+  });
+}
+function _buildFeatureFilter({
+  filters = {},
+  type = "boolean",
+  filtersLogicalOperator = "and"
+}) {
+  const columns = Object.keys(filters);
+  if (!columns.length) {
+    return () => type === "number" ? 1 : true;
+  }
+  return (feature2) => {
+    const f = feature2.properties || feature2;
+    const featurePassesFilter = passesFilter(
+      columns,
+      filters,
+      f,
+      filtersLogicalOperator
+    );
+    return type === "number" ? Number(featurePassesFilter) : featurePassesFilter;
+  };
+}
+function applyFilters(features, filters, filtersLogicalOperator) {
+  return Object.keys(filters).length ? features.filter(_buildFeatureFilter({ filters, filtersLogicalOperator })) : features;
+}
+function buildBinaryFeatureFilter({ filters = {} }) {
+  const columns = Object.keys(filters);
+  if (!columns.length) {
+    return () => 1;
+  }
+  return (featureIdIdx, binaryData) => passesFilterUsingBinary(columns, filters, featureIdIdx, binaryData);
+}
+function getValueFromNumericProps(featureIdIdx, binaryData, { column }) {
+  return binaryData.numericProps?.[column]?.value[featureIdIdx];
+}
+function getValueFromProperties(featureIdIdx, binaryData, { column }) {
+  const propertyIdx = binaryData.featureIds.value[featureIdIdx];
+  return binaryData.properties[propertyIdx]?.[column];
+}
+var GET_VALUE_BY_BINARY_PROP = {
+  properties: getValueFromProperties,
+  numericProps: getValueFromNumericProps
+};
+function getBinaryPropertyByFilterValues(filterValues) {
+  return typeof filterValues.flat()[0] === "string" ? "properties" : "numericProps";
+}
+function getFeatureValue(featureIdIdx, binaryData, filter) {
+  const { column, values } = filter;
+  const binaryProp = getBinaryPropertyByFilterValues(values);
+  const getFeatureValueFn = GET_VALUE_BY_BINARY_PROP[binaryProp];
+  return getFeatureValueFn(featureIdIdx, binaryData, { column });
+}
+function passesFilterUsingBinary(columns, filters, featureIdIdx, binaryData) {
+  return columns.every((column) => {
+    const columnFilters = filters[column];
+    return Object.entries(columnFilters).every(([type, { values }]) => {
+      const filterFn = filterFunctions[type];
+      if (!filterFn) {
+        throw new Error(`"${type}" filter is not implemented.`);
+      }
+      if (!values) return 0;
+      const featureValue = getFeatureValue(featureIdIdx, binaryData, {
+        type,
+        column,
+        values
+      });
+      if (featureValue === void 0 || featureValue === null) return 0;
+      return filterFn(values, featureValue);
+    });
+  });
+}
+
+// src/filters/geosjonFeatures.ts
+import intersects from "@turf/boolean-intersects";
+function geojsonFeatures({
+  geojson,
+  spatialFilter,
+  uniqueIdProperty
+}) {
+  let uniqueIdx = 0;
+  const map = /* @__PURE__ */ new Map();
+  if (!spatialFilter) {
+    return [];
+  }
+  for (const feature2 of geojson.features) {
+    const uniqueId = uniqueIdProperty ? feature2.properties[uniqueIdProperty] : ++uniqueIdx;
+    if (!map.has(uniqueId) && intersects(spatialFilter, feature2)) {
+      map.set(uniqueId, feature2.properties);
+    }
+  }
+  return Array.from(map.values());
+}
+
+// src/filters/tileFeaturesGeometries.ts
+import bboxPolygon from "@turf/bbox-polygon";
+import intersects2 from "@turf/boolean-intersects";
+import booleanWithin from "@turf/boolean-within";
+import intersect from "@turf/intersect";
+
+// node_modules/@math.gl/core/dist/lib/common.js
+var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
+var DEGREES_TO_RADIANS = 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 lerp(a, b, t) {
+  if (isArray(a)) {
+    return a.map((ai, i) => lerp(ai, b[i], t));
+  }
+  return t * b + (1 - t) * a;
+}
+
+// node_modules/@math.gl/web-mercator/dist/assert.js
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "@math.gl/web-mercator: assertion failed.");
+  }
+}
+
+// node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js
+var PI = Math.PI;
+var PI_4 = PI / 4;
+var DEGREES_TO_RADIANS2 = PI / 180;
+var RADIANS_TO_DEGREES2 = 180 / PI;
+var TILE_SIZE = 512;
+function lngLatToWorld(lngLat) {
+  const [lng, lat] = lngLat;
+  assert(Number.isFinite(lng));
+  assert(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude");
+  const lambda2 = lng * DEGREES_TO_RADIANS2;
+  const phi2 = lat * DEGREES_TO_RADIANS2;
+  const x = TILE_SIZE * (lambda2 + PI) / (2 * PI);
+  const y = TILE_SIZE * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5))) / (2 * PI);
+  return [x, y];
+}
+function worldToLngLat(xy) {
+  const [x, y] = xy;
+  const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
+  const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
+  return [lambda2 * RADIANS_TO_DEGREES2, phi2 * RADIANS_TO_DEGREES2];
+}
+
+// node_modules/@math.gl/web-mercator/dist/get-bounds.js
+var DEGREES_TO_RADIANS3 = Math.PI / 180;
+
+// src/utils/transformToTileCoords.ts
+var TRANSFORM_FN = {
+  Point: transformPoint,
+  MultiPoint: transformMultiPoint,
+  LineString: transformLineString,
+  MultiLineString: transformMultiLineString,
+  Polygon: transformPolygon,
+  MultiPolygon: transformMultiPolygon
+};
+function transformToTileCoords(geometry, bbox) {
+  const [west, south, east, north] = bbox;
+  const nw = projectFlat([west, north]);
+  const se = projectFlat([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 = inverseLerp(nw[0], se[0], pointX);
+  const y = inverseLerp(nw[1], se[1], pointY);
+  return [x, y];
+}
+function getPoints(geometry, bbox) {
+  return geometry.map((g) => transformPoint(projectFlat(g), bbox));
+}
+function transformMultiPoint(multiPoint, bbox) {
+  return getPoints(multiPoint, bbox);
+}
+function transformLineString(line, bbox) {
+  return getPoints(line, bbox);
+}
+function transformMultiLineString(multiLineString, bbox) {
+  return multiLineString.map(
+    (lineString) => transformLineString(lineString, bbox)
+  );
+}
+function transformPolygon(polygon2, bbox) {
+  return polygon2.map((polygonRing) => getPoints(polygonRing, bbox));
+}
+function transformMultiPolygon(multiPolygon2, bbox) {
+  return multiPolygon2.map((polygon2) => transformPolygon(polygon2, bbox));
+}
+function projectFlat(xyz) {
+  return lngLatToWorld(xyz);
+}
+function inverseLerp(a, b, x) {
+  return (x - a) / (b - a);
+}
+
+// src/utils/transformTileCoordsToWGS84.ts
+var TRANSFORM_FN2 = {
+  Point: transformPoint2,
+  MultiPoint: transformMultiPoint2,
+  LineString: transformLineString2,
+  MultiLineString: transformMultiLineString2,
+  Polygon: transformPolygon2,
+  MultiPolygon: transformMultiPolygon2
+};
+function transformTileCoordsToWGS84(geometry, bbox) {
+  const [west, south, east, north] = bbox;
+  const nw = lngLatToWorld([west, north]);
+  const se = lngLatToWorld([east, south]);
+  const projectedBbox = [nw, se];
+  if (geometry.type === "GeometryCollection") {
+    throw new Error("Unsupported geometry type GeometryCollection");
+  }
+  const transformFn = TRANSFORM_FN2[geometry.type];
+  const coordinates = transformFn(geometry.coordinates, projectedBbox);
+  return { ...geometry, coordinates };
+}
+function transformPoint2([pointX, pointY], [nw, se]) {
+  const x = lerp(nw[0], se[0], pointX);
+  const y = lerp(nw[1], se[1], pointY);
+  return worldToLngLat([x, y]);
+}
+function getPoints2(geometry, bbox) {
+  return geometry.map((g) => transformPoint2(g, bbox));
+}
+function transformMultiPoint2(multiPoint, bbox) {
+  return getPoints2(multiPoint, bbox);
+}
+function transformLineString2(line, bbox) {
+  return getPoints2(line, bbox);
+}
+function transformMultiLineString2(multiLineString, bbox) {
+  return multiLineString.map(
+    (lineString) => transformLineString2(lineString, bbox)
+  );
+}
+function transformPolygon2(polygon2, bbox) {
+  return polygon2.map((polygonRing) => getPoints2(polygonRing, bbox));
+}
+function transformMultiPolygon2(multiPolygon2, bbox) {
+  return multiPolygon2.map((polygon2) => transformPolygon2(polygon2, bbox));
+}
+
+// src/filters/tileFeaturesGeometries.ts
+import { featureCollection } from "@turf/helpers";
+var FEATURE_GEOM_PROPERTY = "__geomValue";
+function tileFeaturesGeometries({
+  tiles: tiles2,
+  tileFormat,
+  spatialFilter,
+  uniqueIdProperty,
+  options
+}) {
+  const map = /* @__PURE__ */ new Map();
+  for (const tile of tiles2) {
+    if (tile.isVisible === false || !tile.data) {
+      continue;
+    }
+    const bbox = [
+      tile.bbox.west,
+      tile.bbox.south,
+      tile.bbox.east,
+      tile.bbox.north
+    ];
+    const bboxToGeom = bboxPolygon(bbox);
+    const tileIsFullyVisible = booleanWithin(bboxToGeom, spatialFilter);
+    const spatialFilterFeature = {
+      type: "Feature",
+      geometry: spatialFilter,
+      properties: {}
+    };
+    const clippedGeometryToIntersect = intersect(
+      featureCollection([bboxToGeom, spatialFilterFeature])
+    );
+    if (!clippedGeometryToIntersect) {
+      continue;
+    }
+    const transformedGeometryToIntersect = tileFormat === "mvt" /* MVT */ ? transformToTileCoords(clippedGeometryToIntersect.geometry, bbox) : clippedGeometryToIntersect.geometry;
+    createIndicesForPoints(tile.data.points);
+    calculateFeatures({
+      map,
+      tileIsFullyVisible,
+      geometryIntersection: transformedGeometryToIntersect,
+      data: tile.data.points,
+      type: "Point",
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options
+    });
+    calculateFeatures({
+      map,
+      tileIsFullyVisible,
+      geometryIntersection: transformedGeometryToIntersect,
+      data: tile.data.lines,
+      type: "LineString",
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options
+    });
+    calculateFeatures({
+      map,
+      tileIsFullyVisible,
+      geometryIntersection: transformedGeometryToIntersect,
+      data: tile.data.polygons,
+      type: "Polygon",
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options
+    });
+  }
+  return Array.from(map.values());
+}
+function processTileFeatureProperties({
+  map,
+  data,
+  startIndex,
+  endIndex,
+  type,
+  bbox,
+  tileFormat,
+  uniqueIdProperty,
+  storeGeometry,
+  geometryIntersection
+}) {
+  const tileProps = getPropertiesFromTile(data, startIndex);
+  const uniquePropertyValue = getUniquePropertyValue(
+    tileProps,
+    uniqueIdProperty,
+    map
+  );
+  if (!uniquePropertyValue || map.has(uniquePropertyValue)) {
+    return;
+  }
+  let geometry = null;
+  if (storeGeometry || geometryIntersection) {
+    const { positions } = data;
+    const ringCoordinates = getRingCoordinatesFor(
+      startIndex,
+      endIndex,
+      positions
+    );
+    geometry = getFeatureByType(ringCoordinates, type);
+  }
+  if (geometry && geometryIntersection && !intersects2(geometry, geometryIntersection)) {
+    return;
+  }
+  const properties = parseProperties(tileProps);
+  if (storeGeometry && geometry) {
+    properties[FEATURE_GEOM_PROPERTY] = tileFormat === "mvt" /* MVT */ ? transformTileCoordsToWGS84(geometry, bbox) : geometry;
+  }
+  map.set(uniquePropertyValue, properties);
+}
+function addIntersectedFeaturesInTile({
+  map,
+  data,
+  geometryIntersection,
+  type,
+  bbox,
+  tileFormat,
+  uniqueIdProperty,
+  options
+}) {
+  const indices = getIndices(data);
+  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,
+      data,
+      startIndex,
+      endIndex,
+      type,
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      storeGeometry,
+      geometryIntersection
+    });
+  }
+}
+function getIndices(data) {
+  let indices;
+  switch (data.type) {
+    case "Point":
+      indices = data.pointIndices;
+      break;
+    case "LineString":
+      indices = data.pathIndices;
+      break;
+    case "Polygon":
+      indices = data.primitivePolygonIndices;
+      break;
+    default:
+      throw new Error(`Unexpected type, "${data.type}"`);
+  }
+  return indices.value;
+}
+function getFeatureId(data, startIndex) {
+  return data.featureIds.value[startIndex];
+}
+function getPropertiesFromTile(data, startIndex) {
+  const featureId = getFeatureId(data, startIndex);
+  const { properties, numericProps, fields } = data;
+  const result = {
+    uniqueId: fields?.[featureId]?.id,
+    properties: properties[featureId],
+    numericProps: {}
+  };
+  for (const key in numericProps) {
+    result.numericProps[key] = numericProps[key].value[startIndex];
+  }
+  return result;
+}
+function parseProperties(tileProps) {
+  const { properties, numericProps } = tileProps;
+  return Object.assign({}, properties, numericProps);
+}
+function getUniquePropertyValue(tileProps, uniqueIdProperty, map) {
+  if (uniqueIdProperty) {
+    return getValueFromTileProps(tileProps, uniqueIdProperty);
+  }
+  if (tileProps.uniqueId) {
+    return tileProps.uniqueId;
+  }
+  const artificialId = map.size + 1;
+  return getValueFromTileProps(tileProps, "cartodb_id") || getValueFromTileProps(tileProps, "geoid") || artificialId;
+}
+function getValueFromTileProps(tileProps, propertyName) {
+  const { properties, numericProps } = tileProps;
+  return numericProps[propertyName] || properties[propertyName];
+}
+function getFeatureByType(coordinates, type) {
+  switch (type) {
+    case "Polygon":
+      return { type: "Polygon", coordinates: [coordinates] };
+    case "LineString":
+      return { type: "LineString", coordinates };
+    case "Point":
+      return { type: "Point", coordinates: coordinates[0] };
+    default:
+      throw new Error("Invalid geometry type");
+  }
+}
+function getRingCoordinatesFor(startIndex, endIndex, positions) {
+  const ringCoordinates = [];
+  for (let j = startIndex; j < endIndex; j++) {
+    ringCoordinates.push(
+      Array.from(
+        positions.value.subarray(j * positions.size, (j + 1) * positions.size)
+      )
+    );
+  }
+  return ringCoordinates;
+}
+function calculateFeatures({
+  map,
+  tileIsFullyVisible,
+  geometryIntersection,
+  data,
+  type,
+  bbox,
+  tileFormat,
+  uniqueIdProperty,
+  options
+}) {
+  if (!data?.properties.length) {
+    return;
+  }
+  if (tileIsFullyVisible) {
+    addAllFeaturesInTile({
+      map,
+      data,
+      type,
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options
+    });
+  } else {
+    addIntersectedFeaturesInTile({
+      map,
+      data,
+      geometryIntersection,
+      type,
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options
+    });
+  }
+}
+function addAllFeaturesInTile({
+  map,
+  data,
+  type,
+  bbox,
+  tileFormat,
+  uniqueIdProperty,
+  options
+}) {
+  const indices = getIndices(data);
+  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,
+      data,
+      startIndex,
+      endIndex,
+      type,
+      bbox,
+      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);
+  data.pointIndices = pointIndices;
+}
+
+// node_modules/quadbin/dist/esm/index.js
+var import_tile_cover = __toESM(require_tile_cover(), 1);
+var B = [
+  0x5555555555555555n,
+  0x3333333333333333n,
+  0x0f0f0f0f0f0f0f0fn,
+  0x00ff00ff00ff00ffn,
+  0x0000ffff0000ffffn,
+  0x00000000ffffffffn
+];
+var S = [0n, 1n, 2n, 4n, 8n, 16n];
+function tileToCell(tile) {
+  if (tile.z < 0 || tile.z > 26) {
+    throw new Error("Wrong zoom");
+  }
+  const z = BigInt(tile.z);
+  let x = BigInt(tile.x) << 32n - z;
+  let y = BigInt(tile.y) << 32n - z;
+  for (let i = 0; i < 5; i++) {
+    const s = S[5 - i];
+    const b = B[4 - i];
+    x = (x | x << s) & b;
+    y = (y | y << s) & b;
+  }
+  const quadbin = 0x4000000000000000n | 1n << 59n | // | (mode << 59) | (mode_dep << 57)
+  z << 52n | (x | y << 1n) >> 12n | 0xfffffffffffffn >> z * 2n;
+  return quadbin;
+}
+function getResolution(quadbin) {
+  return quadbin >> 52n & 0x1fn;
+}
+function geometryToCells(geometry, resolution) {
+  const zoom = Number(resolution);
+  return (0, import_tile_cover.tiles)(geometry, {
+    min_zoom: zoom,
+    max_zoom: zoom
+  }).map(([x, y, z]) => tileToCell({ x, y, z }));
+}
+
+// src/filters/tileFeaturesSpatialIndex.ts
+import bboxClip from "@turf/bbox-clip";
+import { getResolution as h3GetResolution, polygonToCells } from "h3-js";
+function tileFeaturesSpatialIndex({
+  tiles: tiles2,
+  spatialFilter,
+  spatialDataColumn,
+  spatialDataType
+}) {
+  const map = /* @__PURE__ */ new Map();
+  const spatialIndex = getSpatialIndex(spatialDataType);
+  const resolution = getResolution2(tiles2, spatialIndex);
+  const spatialIndexIDName = spatialDataColumn ? spatialDataColumn : spatialIndex;
+  if (!resolution) {
+    return [];
+  }
+  const cells = getCellsCoverGeometry(spatialFilter, spatialIndex, resolution);
+  if (!cells?.length) {
+    return [];
+  }
+  const cellsSet = new Set(cells);
+  for (const tile of tiles2) {
+    if (tile.isVisible === false || !tile.data) {
+      continue;
+    }
+    tile.data.forEach((d) => {
+      if (cellsSet.has(d.id)) {
+        map.set(d.id, { ...d.properties, [spatialIndexIDName]: d.id });
+      }
+    });
+  }
+  return Array.from(map.values());
+}
+function getResolution2(tiles2, spatialIndex) {
+  const data = tiles2.find((tile) => tile.data?.length)?.data;
+  if (!data) {
+    return;
+  }
+  if (spatialIndex === "quadbin" /* QUADBIN */) {
+    return Number(getResolution(data[0].id));
+  }
+  if (spatialIndex === "h3" /* H3 */) {
+    return h3GetResolution(data[0].id);
+  }
+}
+var bboxWest = [-180, -90, 0, 90];
+var bboxEast = [0, -90, 180, 90];
+function getCellsCoverGeometry(geometry, spatialIndex, resolution) {
+  if (spatialIndex === "quadbin" /* QUADBIN */) {
+    return geometryToCells(geometry, resolution);
+  }
+  if (spatialIndex === "h3" /* H3 */) {
+    return polygonToCells(
+      bboxClip(geometry, bboxWest).geometry.coordinates,
+      resolution,
+      true
+    ).concat(
+      polygonToCells(
+        bboxClip(geometry, bboxEast).geometry.coordinates,
+        resolution,
+        true
+      )
+    );
+  }
+}
+function getSpatialIndex(spatialDataType) {
+  switch (spatialDataType) {
+    case "h3":
+      return "h3" /* H3 */;
+    case "quadbin":
+      return "quadbin" /* QUADBIN */;
+    default:
+      throw new Error("Unexpected spatial data type");
+  }
+}
+
+// src/constants-internal.ts
+var V3_MINOR_VERSION = "3.4";
+var DEFAULT_GEO_COLUMN = "geom";
+var DEFAULT_MAX_LENGTH_URL = 7e3;
+var DEFAULT_TILE_RESOLUTION = 0.5;
+var DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
+var DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
+
+// src/filters/tileFeatures.ts
+function tileFeatures({
+  tiles: tiles2,
+  spatialFilter,
+  uniqueIdProperty,
+  tileFormat,
+  spatialDataColumn = DEFAULT_GEO_COLUMN,
+  spatialDataType,
+  options = {}
+}) {
+  if (spatialDataType !== "geo") {
+    return tileFeaturesSpatialIndex({
+      tiles: tiles2,
+      spatialFilter,
+      spatialDataColumn,
+      spatialDataType
+    });
+  }
+  return tileFeaturesGeometries({
+    tiles: tiles2,
+    tileFormat,
+    spatialFilter,
+    uniqueIdProperty,
+    options
+  });
+}
+
+// src/deck/get-data-filter-extension-props.ts
+function getDataFilterExtensionProps(filters, filtersLogicalOperator, filterSize) {
+  filterSize ?? (filterSize = 4);
+  const { filtersWithoutTimeType, timeColumn, timeFilter } = getFiltersByType(filters);
+  return {
+    filterRange: getFilterRange(timeFilter, filterSize),
+    updateTriggers: getUpdateTriggers(
+      filtersWithoutTimeType,
+      timeColumn,
+      timeFilter
+    ),
+    getFilterValue: getFilterValue(
+      filtersWithoutTimeType,
+      timeColumn,
+      timeFilter,
+      filterSize,
+      filtersLogicalOperator
+    )
+  };
+}
+function getFiltersByType(filters) {
+  const filtersWithoutTimeType = {};
+  let timeColumn = null;
+  let timeFilter = null;
+  for (const [column, columnData] of Object.entries(filters)) {
+    for (const [type, typeData] of Object.entries(columnData)) {
+      if (type === "time" /* TIME */) {
+        timeColumn = column;
+        timeFilter = typeData;
+      } else {
+        filtersWithoutTimeType[column] = { [type]: typeData };
+      }
+    }
+  }
+  return {
+    filtersWithoutTimeType,
+    timeColumn,
+    timeFilter
+  };
+}
+function getFilterRange(timeFilter, filterSize) {
+  const result = Array(filterSize).fill([0, 0]);
+  result[0] = [1, 1];
+  if (timeFilter) {
+    const offsetBy = timeFilter.params?.offsetBy || 0;
+    result[1] = timeFilter.values[0].map((v) => v - offsetBy);
+  }
+  return result;
+}
+function getUpdateTriggers(filtersWithoutTimeType, timeColumn, timeFilter) {
+  const result = { ...filtersWithoutTimeType };
+  if (timeColumn && timeFilter) {
+    result[timeColumn] = {
+      ...result[timeColumn],
+      offsetBy: timeFilter.params?.offsetBy,
+      ["time" /* TIME */]: {}
+      // Allows working with other filters, without an impact on performance.
+    };
+  }
+  return {
+    getFilterValue: JSON.stringify(result)
+  };
+}
+function getFilterValue(filtersWithoutTimeType, timeColumn, timeFilter, filterSize, filtersLogicalOperator) {
+  const result = Array(filterSize).fill(0);
+  const featureFilter = _buildFeatureFilter({
+    filters: filtersWithoutTimeType,
+    type: "number",
+    filtersLogicalOperator
+  });
+  return (feature2) => {
+    result[0] = featureFilter(feature2);
+    if (timeColumn && timeFilter) {
+      const offsetBy = timeFilter.params?.offsetBy || 0;
+      const f = feature2.properties || feature2;
+      result[1] = f[timeColumn] - offsetBy;
+    }
+    return result;
+  };
+}
+
+// src/utils.ts
+var FILTER_TYPES = new Set(Object.values(FilterType));
+var isFilterType = (type) => FILTER_TYPES.has(type);
+function getApplicableFilters(owner, filters) {
+  if (!filters) return {};
+  const applicableFilters = {};
+  for (const column in filters) {
+    for (const type in filters[column]) {
+      if (!isFilterType(type)) continue;
+      const filter = filters[column][type];
+      const isApplicable = !owner || !filter?.owner || filter?.owner !== owner;
+      if (filter && isApplicable) {
+        applicableFilters[column] || (applicableFilters[column] = {});
+        applicableFilters[column][type] = filter;
+      }
+    }
+  }
+  return applicableFilters;
+}
+function normalizeObjectKeys(el) {
+  if (Array.isArray(el)) {
+    return el.map((value) => normalizeObjectKeys(value));
+  } else if (typeof el !== "object") {
+    return el;
+  }
+  return Object.entries(el).reduce(
+    (acc, [key, value]) => {
+      acc[key.toLowerCase()] = typeof value === "object" && value ? normalizeObjectKeys(value) : value;
+      return acc;
+    },
+    {}
+  );
+}
+function assert2(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+var _InvalidColumnError = class _InvalidColumnError extends Error {
+  constructor(message) {
+    super(`${_InvalidColumnError.NAME}: ${message}`);
+    this.name = _InvalidColumnError.NAME;
+  }
+  static is(error) {
+    return error instanceof _InvalidColumnError || error.message?.includes(_InvalidColumnError.NAME);
+  }
+};
+__publicField(_InvalidColumnError, "NAME", "InvalidColumnError");
+var InvalidColumnError = _InvalidColumnError;
+function isEmptyObject(object) {
+  for (const _ in object) {
+    return false;
+  }
+  return true;
+}
+var isObject = (x) => x !== null && typeof x === "object";
+var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
+
+// src/filters.ts
+function addFilter(filters, { column, type, values, owner }) {
+  if (!filters[column]) {
+    filters[column] = {};
+  }
+  const filter = { values, owner };
+  filters[column][type] = filter;
+  return filters;
+}
+function removeFilter(filters, { column, owner }) {
+  const filter = filters[column];
+  if (!filter) {
+    return filters;
+  }
+  if (owner) {
+    for (const type of Object.values(FilterType)) {
+      if (owner === filter[type]?.owner) {
+        delete filter[type];
+      }
+    }
+  }
+  if (!owner || isEmptyObject(filter)) {
+    delete filters[column];
+  }
+  return filters;
+}
+function clearFilters(filters) {
+  for (const column of Object.keys(filters)) {
+    delete filters[column];
+  }
+  return filters;
+}
+function hasFilter(filters, { column, owner }) {
+  const filter = filters[column];
+  if (!filter) {
+    return false;
+  }
+  if (!owner) {
+    return true;
+  }
+  for (const type of Object.values(FilterType)) {
+    if (owner === filter[type]?.owner) {
+      return true;
+    }
+  }
+  return false;
+}
+function getFilter(filters, { column, type, owner }) {
+  const filter = filters[column];
+  if (!filter) {
+    return null;
+  }
+  if (!owner || owner === filter[type]?.owner) {
+    return filter[type] || null;
+  }
+  return null;
+}
+
+// src/geo.ts
+import bboxClip2 from "@turf/bbox-clip";
+import bboxPolygon2 from "@turf/bbox-polygon";
+import union from "@turf/union";
+import { getType } from "@turf/invariant";
+import { polygon, multiPolygon, feature, featureCollection as featureCollection2 } from "@turf/helpers";
+function createViewportSpatialFilter(viewport) {
+  if (_isGlobalViewport(viewport)) {
+    return;
+  }
+  return createPolygonSpatialFilter(bboxPolygon2(viewport).geometry);
+}
+function createPolygonSpatialFilter(spatialFilter) {
+  return spatialFilter && _normalizeGeometry(spatialFilter) || void 0;
+}
+function _isGlobalViewport(viewport) {
+  const [minx, miny, maxx, maxy] = viewport;
+  return maxx - minx > 179.5 * 2 && maxy - miny > 85.05 * 2;
+}
+function _normalizeGeometry(geometry) {
+  const WORLD = [-180, -90, 180, 90];
+  const worldClip = _clean(
+    bboxClip2(geometry, WORLD).geometry
+  );
+  const geometryTxWest = _tx(geometry, 360);
+  const geometryTxEast = _tx(geometry, -360);
+  let result = worldClip;
+  if (result && geometryTxWest) {
+    const worldWestClip = _clean(
+      bboxClip2(geometryTxWest, WORLD).geometry
+    );
+    if (worldWestClip) {
+      const collection = featureCollection2([
+        feature(result),
+        feature(worldWestClip)
+      ]);
+      const merged = union(collection);
+      result = merged ? _clean(merged.geometry) : result;
+    }
+  }
+  if (result && geometryTxEast) {
+    const worldEastClip = _clean(
+      bboxClip2(geometryTxEast, WORLD).geometry
+    );
+    if (worldEastClip) {
+      const collection = featureCollection2([
+        feature(result),
+        feature(worldEastClip)
+      ]);
+      const merged = union(collection);
+      result = merged ? _clean(merged.geometry) : result;
+    }
+  }
+  return result;
+}
+function _cleanPolygonCoords(cc) {
+  const coords = cc.filter((c) => c.length > 0);
+  return coords.length > 0 ? coords : null;
+}
+function _cleanMultiPolygonCoords(ccc) {
+  const coords = ccc.map(_cleanPolygonCoords).filter((cc) => cc);
+  return coords.length > 0 ? coords : null;
+}
+function _clean(geometry) {
+  if (!geometry) {
+    return null;
+  }
+  if (_isPolygon(geometry)) {
+    const coords = _cleanPolygonCoords(geometry.coordinates);
+    return coords ? polygon(coords).geometry : null;
+  }
+  if (_isMultiPolygon(geometry)) {
+    const coords = _cleanMultiPolygonCoords(geometry.coordinates);
+    return coords ? multiPolygon(coords).geometry : null;
+  }
+  return null;
+}
+function _txContourCoords(cc, distance) {
+  return cc.map((c) => [c[0] + distance, c[1]]);
+}
+function _txPolygonCoords(ccc, distance) {
+  return ccc.map((cc) => _txContourCoords(cc, distance));
+}
+function _txMultiPolygonCoords(cccc, distance) {
+  return cccc.map((ccc) => _txPolygonCoords(ccc, distance));
+}
+function _tx(geometry, distance) {
+  if (geometry && getType(geometry) === "Polygon") {
+    const coords = _txPolygonCoords(
+      geometry.coordinates,
+      distance
+    );
+    return polygon(coords).geometry;
+  } else if (geometry && getType(geometry) === "MultiPolygon") {
+    const coords = _txMultiPolygonCoords(
+      geometry.coordinates,
+      distance
+    );
+    return multiPolygon(coords).geometry;
+  } else {
+    return null;
+  }
+}
+function _isPolygon(geometry) {
+  return getType(geometry) === "Polygon";
+}
+function _isMultiPolygon(geometry) {
+  return getType(geometry) === "MultiPolygon";
+}
+
+// src/api/endpoints.ts
+function joinPath(...args) {
+  return args.map((part) => part.endsWith("/") ? part.slice(0, -1) : part).join("/");
+}
+function buildV3Path(apiBaseUrl, version, endpoint, ...rest) {
+  return joinPath(apiBaseUrl, version, endpoint, ...rest);
+}
+function buildPublicMapUrl({
+  apiBaseUrl,
+  cartoMapId
+}) {
+  return buildV3Path(apiBaseUrl, "v3", "maps", "public", cartoMapId);
+}
+function buildStatsUrl({
+  attribute,
+  apiBaseUrl,
+  connectionName,
+  source,
+  type
+}) {
+  if (type === "query") {
+    return buildV3Path(apiBaseUrl, "v3", "stats", connectionName, attribute);
+  }
+  return buildV3Path(
+    apiBaseUrl,
+    "v3",
+    "stats",
+    connectionName,
+    source,
+    attribute
+  );
+}
+function buildSourceUrl({
+  apiBaseUrl,
+  connectionName,
+  endpoint
+}) {
+  return buildV3Path(apiBaseUrl, "v3", "maps", connectionName, endpoint);
+}
+function buildQueryUrl({
+  apiBaseUrl,
+  connectionName
+}) {
+  return buildV3Path(apiBaseUrl, "v3", "sql", connectionName, "query");
+}
+
+// src/api/carto-api-error.ts
+var CartoAPIError = class extends Error {
+  constructor(error, errorContext, response, responseJson) {
+    let responseString = "Failed to connect";
+    if (response) {
+      responseString = "Server returned: ";
+      if (response.status === 400) {
+        responseString += "Bad request";
+      } else if (response.status === 401 || response.status === 403) {
+        responseString += "Unauthorized access";
+      } else if (response.status === 404) {
+        responseString += "Not found";
+      } else {
+        responseString += "Error";
+      }
+      responseString += ` (${response.status}):`;
+    }
+    responseString += ` ${error.message || error}`;
+    let message = `${errorContext.requestType} API request failed`;
+    message += `
+${responseString}`;
+    for (const key of Object.keys(errorContext)) {
+      if (key === "requestType") continue;
+      message += `
+${formatErrorKey(key)}: ${errorContext[key]}`;
+    }
+    message += "\n";
+    super(message);
+    /** Source error from server */
+    __publicField(this, "error");
+    /** Context (API call & parameters) in which error occured */
+    __publicField(this, "errorContext");
+    /** Response from server */
+    __publicField(this, "response");
+    /** JSON Response from server */
+    __publicField(this, "responseJson");
+    this.name = "CartoAPIError";
+    this.response = response;
+    this.responseJson = responseJson;
+    this.error = error;
+    this.errorContext = errorContext;
+  }
+};
+function formatErrorKey(key) {
+  return key.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase());
+}
+
+// src/api/request-with-parameters.ts
+var DEFAULT_HEADERS = {
+  Accept: "application/json",
+  "Content-Type": "application/json"
+};
+var DEFAULT_REQUEST_CACHE = /* @__PURE__ */ new Map();
+async function requestWithParameters({
+  baseUrl,
+  parameters = {},
+  headers: customHeaders = {},
+  errorContext,
+  maxLengthURL = DEFAULT_MAX_LENGTH_URL,
+  localCache
+}) {
+  parameters = {
+    v: V3_MINOR_VERSION,
+    client: getClient(),
+    ...typeof deck !== "undefined" && deck.VERSION && { deckglVersion: deck.VERSION },
+    ...parameters
+  };
+  baseUrl = excludeURLParameters(baseUrl, Object.keys(parameters));
+  const key = createCacheKey(baseUrl, parameters, customHeaders);
+  const {
+    cache: REQUEST_CACHE,
+    canReadCache,
+    canStoreInCache
+  } = getCacheSettings(localCache);
+  if (canReadCache && REQUEST_CACHE.has(key)) {
+    return REQUEST_CACHE.get(key);
+  }
+  const url = createURLWithParameters(baseUrl, parameters);
+  const headers = { ...DEFAULT_HEADERS, ...customHeaders };
+  const fetchPromise = url.length > maxLengthURL ? fetch(baseUrl, {
+    method: "POST",
+    body: JSON.stringify(parameters),
+    headers
+  }) : fetch(url, { headers });
+  let response;
+  let responseJson;
+  const jsonPromise = fetchPromise.then((_response) => {
+    response = _response;
+    return response.json();
+  }).then((json) => {
+    responseJson = json;
+    if (!response || !response.ok) {
+      throw new Error(json.error);
+    }
+    return json;
+  }).catch((error) => {
+    if (canStoreInCache) {
+      REQUEST_CACHE.delete(key);
+    }
+    throw new CartoAPIError(error, errorContext, response, responseJson);
+  });
+  if (canStoreInCache) {
+    REQUEST_CACHE.set(key, jsonPromise);
+  }
+  return jsonPromise;
+}
+function getCacheSettings(localCache) {
+  const canReadCache = localCache?.cacheControl?.includes("no-cache") ? false : true;
+  const canStoreInCache = localCache?.cacheControl?.includes("no-store") ? false : true;
+  const cache = localCache?.cache || DEFAULT_REQUEST_CACHE;
+  return {
+    cache,
+    canReadCache,
+    canStoreInCache
+  };
+}
+function createCacheKey(baseUrl, parameters, headers) {
+  const parameterEntries = Object.entries(parameters).sort(
+    ([a], [b]) => a > b ? 1 : -1
+  );
+  const headerEntries = Object.entries(headers).sort(
+    ([a], [b]) => a > b ? 1 : -1
+  );
+  return JSON.stringify({
+    baseUrl,
+    parameters: parameterEntries,
+    headers: headerEntries
+  });
+}
+function createURLWithParameters(baseUrlString, parameters) {
+  const baseUrl = new URL(baseUrlString);
+  for (const [key, value] of Object.entries(parameters)) {
+    if (isPureObject(value) || Array.isArray(value)) {
+      baseUrl.searchParams.set(key, JSON.stringify(value));
+    } else {
+      baseUrl.searchParams.set(
+        key,
+        value.toString()
+      );
+    }
+  }
+  return baseUrl.toString();
+}
+function excludeURLParameters(baseUrlString, parameters) {
+  const baseUrl = new URL(baseUrlString);
+  for (const param of parameters) {
+    if (baseUrl.searchParams.has(param)) {
+      baseUrl.searchParams.delete(param);
+    }
+  }
+  return baseUrl.toString();
+}
+
+// src/sources/base-source.ts
+var SOURCE_DEFAULTS = {
+  apiBaseUrl: DEFAULT_API_BASE_URL,
+  clientId: getClient(),
+  format: "tilejson",
+  headers: {},
+  maxLengthURL: DEFAULT_MAX_LENGTH_URL
+};
+async function baseSource(endpoint, options, urlParameters) {
+  const { accessToken, connectionName, cache, ...optionalOptions } = options;
+  const mergedOptions = {
+    ...SOURCE_DEFAULTS,
+    accessToken,
+    connectionName,
+    endpoint
+  };
+  for (const key in optionalOptions) {
+    if (optionalOptions[key]) {
+      mergedOptions[key] = optionalOptions[key];
+    }
+  }
+  const baseUrl = buildSourceUrl(mergedOptions);
+  const { clientId, maxLengthURL, format, localCache } = mergedOptions;
+  const headers = {
+    Authorization: `Bearer ${options.accessToken}`,
+    ...options.headers
+  };
+  const parameters = { client: clientId, ...urlParameters };
+  const errorContext = {
+    requestType: "Map instantiation",
+    connection: options.connectionName,
+    type: endpoint,
+    source: JSON.stringify(parameters, void 0, 2)
+  };
+  const mapInstantiation = await requestWithParameters({
+    baseUrl,
+    parameters,
+    headers,
+    errorContext,
+    maxLengthURL,
+    localCache
+  });
+  const dataUrl = mapInstantiation[format].url[0];
+  if (cache) {
+    cache.value = parseInt(
+      new URL(dataUrl).searchParams.get("cache") || "",
+      10
+    );
+  }
+  errorContext.requestType = "Map data";
+  if (format === "tilejson") {
+    const json = await requestWithParameters({
+      baseUrl: dataUrl,
+      headers,
+      errorContext,
+      maxLengthURL,
+      localCache
+    });
+    if (accessToken) {
+      json.accessToken = accessToken;
+    }
+    return json;
+  }
+  return await requestWithParameters({
+    baseUrl: dataUrl,
+    headers,
+    errorContext,
+    maxLengthURL,
+    localCache
+  });
+}
+
+// src/sources/boundary-query-source.ts
+var boundaryQuerySource = async function(options) {
+  const {
+    columns,
+    filters,
+    tilesetTableName,
+    propertiesSqlQuery,
+    queryParameters
+  } = options;
+  const urlParameters = {
+    tilesetTableName,
+    propertiesSqlQuery
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(",");
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  return baseSource(
+    "boundary",
+    options,
+    urlParameters
+  );
+};
+
+// src/sources/boundary-table-source.ts
+var boundaryTableSource = async function(options) {
+  const { filters, tilesetTableName, columns, propertiesTableName } = options;
+  const urlParameters = {
+    tilesetTableName,
+    propertiesTableName
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(",");
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource(
+    "boundary",
+    options,
+    urlParameters
+  );
+};
+
+// src/spatial-index.ts
+var DEFAULT_TILE_SIZE = 512;
+var QUADBIN_ZOOM_MAX_OFFSET = 4;
+function getSpatialFiltersResolution(source, viewState) {
+  const dataResolution = source.dataResolution ?? Number.MAX_VALUE;
+  const aggregationResLevel = source.aggregationResLevel ?? (source.spatialDataType === "h3" ? DEFAULT_AGGREGATION_RES_LEVEL_H3 : DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN);
+  const aggregationResLevelOffset = Math.max(
+    0,
+    Math.floor(aggregationResLevel)
+  );
+  const currentZoomInt = Math.ceil(viewState.zoom);
+  if (source.spatialDataType === "h3") {
+    const tileSize = DEFAULT_TILE_SIZE;
+    const maxResolutionForZoom = maxH3SpatialFiltersResolutions.find(
+      ([zoom]) => zoom === currentZoomInt
+    )?.[1] ?? Math.max(0, currentZoomInt - 3);
+    const maxSpatialFiltersResolution = maxResolutionForZoom ? Math.min(dataResolution, maxResolutionForZoom) : dataResolution;
+    const hexagonResolution = _getHexagonResolution(viewState, tileSize) + aggregationResLevelOffset;
+    return Math.min(hexagonResolution, maxSpatialFiltersResolution);
+  }
+  if (source.spatialDataType === "quadbin") {
+    const maxResolutionForZoom = currentZoomInt + QUADBIN_ZOOM_MAX_OFFSET;
+    const maxSpatialFiltersResolution = Math.min(
+      dataResolution,
+      maxResolutionForZoom
+    );
+    const quadsResolution = Math.floor(viewState.zoom) + aggregationResLevelOffset;
+    return Math.min(quadsResolution, maxSpatialFiltersResolution);
+  }
+  return void 0;
+}
+var maxH3SpatialFiltersResolutions = [
+  [20, 14],
+  [19, 13],
+  [18, 12],
+  [17, 11],
+  [16, 10],
+  [15, 9],
+  [14, 8],
+  [13, 7],
+  [12, 7],
+  [11, 7],
+  [10, 6],
+  [9, 6],
+  [8, 5],
+  [7, 4],
+  [6, 4],
+  [5, 3],
+  [4, 2],
+  [3, 1],
+  [2, 1],
+  [1, 0]
+];
+var BIAS = 2;
+function _getHexagonResolution(viewport, tileSize) {
+  const zoomOffset = Math.log2(tileSize / DEFAULT_TILE_SIZE);
+  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)
+  );
+}
+
+// src/widget-sources/widget-source.ts
+var _WidgetSource = class _WidgetSource {
+  constructor(props) {
+    __publicField(this, "props");
+    this.props = { ..._WidgetSource.defaultProps, ...props };
+  }
+  /**
+   * Destroys the widget source and releases allocated resources.
+   *
+   * For remote sources (tables, queries) this has no effect, but for local
+   * sources (tilesets, rasters) these resources will affect performance
+   * and stability if many (10+) sources are created and not released.
+   */
+  destroy() {
+  }
+  _getSpatialFiltersResolution(source, spatialFilter, referenceViewState) {
+    if (!spatialFilter || source.spatialDataType === "geo") {
+      return;
+    }
+    if (!referenceViewState) {
+      throw new Error(
+        'Missing required option, "spatialIndexReferenceViewState".'
+      );
+    }
+    return getSpatialFiltersResolution(source, referenceViewState);
+  }
+};
+__publicField(_WidgetSource, "defaultProps", {
+  apiVersion: "v3" /* V3 */,
+  apiBaseUrl: DEFAULT_API_BASE_URL,
+  clientId: getClient(),
+  filters: {},
+  filtersLogicalOperator: "and"
+});
+var WidgetSource = _WidgetSource;
+
+// src/models/common.ts
+function dealWithApiError({
+  response,
+  data
+}) {
+  if (data.error === "Column not found") {
+    throw new InvalidColumnError(`${data.error} ${data.column_name}`);
+  }
+  if (typeof data.error === "string" && data.error?.includes("Missing columns")) {
+    throw new InvalidColumnError(data.error);
+  }
+  switch (response.status) {
+    case 401:
+      throw new Error("Unauthorized access. Invalid credentials");
+    case 403:
+      throw new Error("Forbidden access to the requested data");
+    default:
+      throw new Error(
+        data && data.error && typeof data.error === "string" ? data.error : JSON.stringify(data?.hint || data.error?.[0])
+      );
+  }
+}
+async function makeCall({
+  url,
+  accessToken,
+  opts
+}) {
+  let response;
+  let data;
+  const isPost = opts?.method === "POST";
+  try {
+    response = await fetch(url.toString(), {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        ...isPost && { "Content-Type": "application/json" },
+        ...opts.headers
+      },
+      ...isPost && {
+        method: opts?.method,
+        body: opts?.body
+      },
+      signal: opts?.signal,
+      ...opts?.otherOptions
+    });
+    data = await response.json();
+  } catch (error) {
+    if (error.name === "AbortError") throw error;
+    throw new Error(`Failed request: ${error}`);
+  }
+  if (!response.ok) {
+    dealWithApiError({ response, data });
+  }
+  return data;
+}
+
+// src/models/model.ts
+var AVAILABLE_MODELS = [
+  "category",
+  "histogram",
+  "formula",
+  "pick",
+  "timeseries",
+  "range",
+  "scatterplot",
+  "table"
+];
+var { V3 } = ApiVersion;
+var REQUEST_GET_MAX_URL_LENGTH = 2048;
+function executeModel(props) {
+  assert2(props.source, "executeModel: missing source");
+  assert2(props.model, "executeModel: missing model");
+  assert2(props.params, "executeModel: missing params");
+  assert2(
+    AVAILABLE_MODELS.includes(props.model),
+    `executeModel: model provided isn't valid. Available models: ${AVAILABLE_MODELS.join(
+      ", "
+    )}`
+  );
+  const { model, source, params, opts } = props;
+  const { type, apiVersion, apiBaseUrl, accessToken, connectionName, clientId } = source;
+  assert2(apiBaseUrl, "executeModel: missing apiBaseUrl");
+  assert2(accessToken, "executeModel: missing accessToken");
+  assert2(apiVersion === V3, "executeModel: SQL Model API requires CARTO 3+");
+  assert2(type !== "tileset", "executeModel: Tilesets not supported");
+  let url = `${apiBaseUrl}/v3/sql/${connectionName}/model/${model}`;
+  const {
+    data,
+    filters,
+    filtersLogicalOperator = "and",
+    spatialDataType = "geo",
+    spatialFiltersMode = "intersects",
+    spatialFiltersResolution = 0
+  } = source;
+  const queryParams = {
+    type,
+    client: clientId,
+    source: data,
+    params,
+    queryParameters: source.queryParameters || "",
+    filters,
+    filtersLogicalOperator
+  };
+  const spatialDataColumn = source.spatialDataColumn || DEFAULT_GEO_COLUMN;
+  if (model === "pick") {
+    queryParams.spatialDataColumn = spatialDataColumn;
+  }
+  const spatialFilters = source.spatialFilter ? { [spatialDataColumn]: source.spatialFilter } : void 0;
+  if (spatialFilters) {
+    queryParams.spatialFilters = spatialFilters;
+    queryParams.spatialDataColumn = spatialDataColumn;
+    queryParams.spatialDataType = spatialDataType;
+  }
+  if (spatialDataType !== "geo") {
+    if (spatialFiltersResolution > 0) {
+      queryParams.spatialFiltersResolution = spatialFiltersResolution;
+    }
+    queryParams.spatialFiltersMode = spatialFiltersMode;
+  }
+  const urlWithSearchParams = url + "?" + objectToURLSearchParams(queryParams).toString();
+  const isGet = urlWithSearchParams.length <= REQUEST_GET_MAX_URL_LENGTH;
+  if (isGet) {
+    url = urlWithSearchParams;
+  }
+  return makeCall({
+    url,
+    accessToken: source.accessToken,
+    opts: {
+      ...opts,
+      method: isGet ? "GET" : "POST",
+      ...!isGet && { body: JSON.stringify(queryParams) }
+    }
+  });
+}
+function objectToURLSearchParams(object) {
+  const params = new URLSearchParams();
+  for (const key in object) {
+    if (isPureObject(object[key])) {
+      params.append(key, JSON.stringify(object[key]));
+    } else if (Array.isArray(object[key])) {
+      params.append(key, JSON.stringify(object[key]));
+    } else if (object[key] === null) {
+      params.append(key, "null");
+    } else if (object[key] !== void 0) {
+      params.append(key, String(object[key]));
+    }
+  }
+  return params;
+}
+
+// src/widget-sources/widget-remote-source.ts
+var WidgetRemoteSource = class extends WidgetSource {
+  _getModelSource(filters, filterOwner) {
+    const props = this.props;
+    return {
+      apiVersion: props.apiVersion,
+      apiBaseUrl: props.apiBaseUrl,
+      clientId: props.clientId,
+      accessToken: props.accessToken,
+      connectionName: props.connectionName,
+      filters: getApplicableFilters(filterOwner, filters || props.filters),
+      filtersLogicalOperator: props.filtersLogicalOperator,
+      spatialDataType: props.spatialDataType,
+      spatialDataColumn: props.spatialDataColumn,
+      dataResolution: props.dataResolution
+    };
+  }
+  async getCategories(options) {
+    const {
+      signal,
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      ...params
+    } = options;
+    const { column, operation, operationColumn } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    return executeModel({
+      model: "category",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: {
+        column,
+        operation,
+        operationColumn: operationColumn || column
+      },
+      opts: { signal, headers: this.props.headers }
+    }).then((res) => normalizeObjectKeys(res.rows));
+  }
+  async getFeatures(options) {
+    const {
+      signal,
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      ...params
+    } = options;
+    const { columns, dataType, featureIds, z, limit, tileResolution } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    return executeModel({
+      model: "pick",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: {
+        columns,
+        dataType,
+        featureIds,
+        z,
+        limit: limit || 1e3,
+        tileResolution: tileResolution || DEFAULT_TILE_RESOLUTION
+      },
+      opts: { signal, headers: this.props.headers }
+      // Avoid `normalizeObjectKeys()`, which changes column names.
+    }).then(({ rows }) => ({ rows }));
+  }
+  async getFormula(options) {
+    const {
+      signal,
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      operationExp,
+      ...params
+    } = options;
+    const { column, operation } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    return executeModel({
+      model: "formula",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: {
+        column: column ?? "*",
+        operation: operation ?? "count",
+        operationExp
+      },
+      opts: { signal, headers: this.props.headers }
+    }).then((res) => normalizeObjectKeys(res.rows[0]));
+  }
+  async getHistogram(options) {
+    const {
+      signal,
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      ...params
+    } = options;
+    const { column, operation, ticks } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    const data = await executeModel({
+      model: "histogram",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: { column, operation, ticks },
+      opts: { signal, headers: this.props.headers }
+    }).then((res) => normalizeObjectKeys(res.rows));
+    if (data.length) {
+      const result = Array(ticks.length + 1).fill(0);
+      data.forEach(
+        ({ tick, value }) => result[tick] = value
+      );
+      return result;
+    }
+    return [];
+  }
+  async getRange(options) {
+    const {
+      signal,
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      ...params
+    } = options;
+    const { column } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    return executeModel({
+      model: "range",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: { column },
+      opts: { signal, headers: this.props.headers }
+    }).then((res) => normalizeObjectKeys(res.rows[0]));
+  }
+  async getScatter(options) {
+    const {
+      signal,
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      ...params
+    } = options;
+    const { xAxisColumn, xAxisJoinOperation, yAxisColumn, yAxisJoinOperation } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    const HARD_LIMIT = 500;
+    return executeModel({
+      model: "scatterplot",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: {
+        xAxisColumn,
+        xAxisJoinOperation,
+        yAxisColumn,
+        yAxisJoinOperation,
+        limit: HARD_LIMIT
+      },
+      opts: { signal, headers: this.props.headers }
+    }).then((res) => normalizeObjectKeys(res.rows)).then((res) => res.map(({ x, y }) => [x, y]));
+  }
+  async getTable(options) {
+    const {
+      signal,
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      ...params
+    } = options;
+    const { columns, sortBy, sortDirection, offset = 0, limit = 10 } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    return executeModel({
+      model: "table",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: {
+        column: columns,
+        sortBy,
+        sortDirection,
+        limit,
+        offset
+      },
+      opts: { signal, headers: this.props.headers }
+    }).then((res) => ({
+      // Avoid `normalizeObjectKeys()`, which changes column names.
+      rows: res.rows ?? res.ROWS,
+      totalCount: res.metadata?.total ?? res.METADATA?.TOTAL
+    }));
+  }
+  async getTimeSeries(options) {
+    const {
+      signal,
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      ...params
+    } = options;
+    const {
+      column,
+      operationColumn,
+      joinOperation,
+      operation,
+      stepSize,
+      stepMultiplier,
+      splitByCategory,
+      splitByCategoryLimit,
+      splitByCategoryValues
+    } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    return executeModel({
+      model: "timeseries",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: {
+        column,
+        stepSize,
+        stepMultiplier,
+        operationColumn: operationColumn || column,
+        joinOperation,
+        operation,
+        splitByCategory,
+        splitByCategoryLimit,
+        splitByCategoryValues
+      },
+      opts: { signal, headers: this.props.headers }
+    }).then((res) => ({
+      rows: normalizeObjectKeys(res.rows),
+      categories: res.metadata?.categories
+    }));
+  }
+};
+
+// src/widget-sources/widget-query-source.ts
+var WidgetQuerySource = class extends WidgetRemoteSource {
+  getModelSource(filters, filterOwner) {
+    return {
+      ...super._getModelSource(filters, filterOwner),
+      type: "query",
+      data: this.props.sqlQuery,
+      queryParameters: this.props.queryParameters
+    };
+  }
+};
+
+// src/widget-sources/widget-table-source.ts
+var WidgetTableSource = class extends WidgetRemoteSource {
+  getModelSource(filters, filterOwner) {
+    return {
+      ...super._getModelSource(filters, filterOwner),
+      type: "table",
+      data: this.props.tableName
+    };
+  }
+};
+
+// src/operations/aggregation.ts
+var aggregationFunctions = {
+  count: (values) => values.length,
+  min: (...args) => applyAggregationFunction(min, ...args),
+  max: (...args) => applyAggregationFunction(max, ...args),
+  sum: (...args) => applyAggregationFunction(sum, ...args),
+  avg: (...args) => applyAggregationFunction(avg, ...args)
+};
+function aggregate(feature2, keys, operation) {
+  if (!keys?.length) {
+    throw new Error("Cannot aggregate a feature without having keys");
+  } else if (keys.length === 1) {
+    const value = feature2[keys[0]];
+    return isPotentiallyValidNumber(value) ? Number(value) : value;
+  }
+  const aggregationFn = aggregationFunctions[operation];
+  if (!aggregationFn) {
+    throw new Error(`${operation} isn't a valid aggregation function`);
+  }
+  return aggregationFn(
+    keys.map((column) => {
+      const value = feature2[column];
+      return isPotentiallyValidNumber(value) ? Number(value) : value;
+    })
+  );
+}
+function isPotentiallyValidNumber(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+var applyAggregationFunction = (aggFn, values, keys, operation) => {
+  const normalizedKeys = normalizeKeys(keys);
+  const elements = (normalizedKeys?.length || 0) <= 1 ? filterFalsyElements(values, normalizedKeys || []) : values;
+  return aggFn(elements, keys, operation);
+};
+function filterFalsyElements(values, keys) {
+  const filterFn = (value) => value !== null && value !== void 0;
+  if (!keys?.length) {
+    return values.filter(filterFn);
+  }
+  return values.filter((v) => filterFn(v[keys[0]]));
+}
+function avg(values, keys, joinOperation) {
+  return sum(values, keys, joinOperation) / (values.length || 1);
+}
+function sum(values, keys, joinOperation) {
+  const normalizedKeys = normalizeKeys(keys);
+  if (normalizedKeys) {
+    return values.reduce(
+      (a, b) => a + aggregate(b, normalizedKeys, joinOperation),
+      0
+    );
+  }
+  return values.reduce((a, b) => a + b, 0);
+}
+function min(values, keys, joinOperation) {
+  const normalizedKeys = normalizeKeys(keys);
+  if (normalizedKeys) {
+    return values.reduce(
+      (a, b) => Math.min(a, aggregate(b, normalizedKeys, joinOperation)),
+      Infinity
+    );
+  }
+  return Math.min(...values);
+}
+function max(values, keys, joinOperation) {
+  const normalizedKeys = normalizeKeys(keys);
+  if (normalizedKeys) {
+    return values.reduce(
+      (a, b) => Math.max(a, aggregate(b, normalizedKeys, joinOperation)),
+      -Infinity
+    );
+  }
+  return Math.max(...values);
+}
+function normalizeKeys(keys) {
+  return Array.isArray(keys) ? keys : typeof keys === "string" ? [keys] : void 0;
+}
+
+// src/operations/applySorting.ts
+var import_thenby = __toESM(require_thenBy_module(), 1);
+function applySorting(features, {
+  sortBy,
+  sortByDirection = "asc",
+  sortByColumnType = "string"
+} = {}) {
+  if (sortBy === void 0) {
+    return features;
+  }
+  const isValidSortBy = Array.isArray(sortBy) && sortBy.length || // sortBy can be an array of columns
+  typeof sortBy === "string";
+  if (!isValidSortBy) {
+    throw new Error("Sorting options are bad formatted");
+  }
+  const sortFn = createSortFn({
+    sortBy,
+    sortByDirection,
+    sortByColumnType: sortByColumnType || "string"
+  });
+  return features.sort(sortFn);
+}
+function createSortFn({
+  sortBy,
+  sortByDirection,
+  sortByColumnType
+}) {
+  const [firstSortOption, ...othersSortOptions] = normalizeSortByOptions({
+    sortBy,
+    sortByDirection,
+    sortByColumnType
+  });
+  let sortFn = (0, import_thenby.firstBy)(...firstSortOption);
+  for (const sortOptions of othersSortOptions) {
+    sortFn = sortFn.thenBy(...sortOptions);
+  }
+  return sortFn;
+}
+function normalizeSortByOptions({
+  sortBy,
+  sortByDirection,
+  sortByColumnType
+}) {
+  const numberFormat = sortByColumnType === "number" && {
+    cmp: (a, b) => a - b
+  };
+  if (!Array.isArray(sortBy)) {
+    sortBy = [sortBy];
+  }
+  return sortBy.map((sortByEl) => {
+    if (typeof sortByEl === "string") {
+      return [sortByEl, { direction: sortByDirection, ...numberFormat }];
+    }
+    if (Array.isArray(sortByEl)) {
+      if (sortByEl[1] === void 0) {
+        return [sortByEl, { direction: sortByDirection, ...numberFormat }];
+      }
+      if (typeof sortByEl[1] === "object") {
+        const othersSortOptions = numberFormat ? { ...numberFormat, ...sortByEl[1] } : sortByEl[1];
+        return [
+          sortByEl[0],
+          { direction: sortByDirection, ...othersSortOptions }
+        ];
+      }
+    }
+    return sortByEl;
+  });
+}
+
+// src/operations/groupBy.ts
+function groupValuesByColumn({
+  data,
+  valuesColumns,
+  joinOperation,
+  keysColumn,
+  operation
+}) {
+  if (Array.isArray(data) && data.length === 0) {
+    return null;
+  }
+  const groups = data.reduce((accumulator, item) => {
+    const group = item[keysColumn];
+    const values = accumulator.get(group) || [];
+    accumulator.set(group, values);
+    const aggregatedValue = aggregate(item, valuesColumns, joinOperation);
+    const isValid = (operation === "count" ? true : aggregatedValue !== null) && aggregatedValue !== void 0;
+    if (isValid) {
+      values.push(aggregatedValue);
+      accumulator.set(group, values);
+    }
+    return accumulator;
+  }, /* @__PURE__ */ new Map());
+  const targetOperation = aggregationFunctions[operation];
+  if (targetOperation) {
+    return Array.from(groups).map(([name, value]) => ({
+      name,
+      value: targetOperation(value)
+    }));
+  }
+  return [];
+}
+
+// src/utils/dateUtils.ts
+function getUTCMonday(date) {
+  const dateCp = new Date(date);
+  const day = dateCp.getUTCDay();
+  const diff = dateCp.getUTCDate() - day + (day ? 1 : -6);
+  dateCp.setUTCDate(diff);
+  return Date.UTC(
+    dateCp.getUTCFullYear(),
+    dateCp.getUTCMonth(),
+    dateCp.getUTCDate()
+  );
+}
+
+// src/operations/groupByDate.ts
+var GROUP_KEY_FN_MAPPING = {
+  year: (date) => Date.UTC(date.getUTCFullYear()),
+  month: (date) => Date.UTC(date.getUTCFullYear(), date.getUTCMonth()),
+  week: (date) => getUTCMonday(date),
+  day: (date) => Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()),
+  hour: (date) => Date.UTC(
+    date.getUTCFullYear(),
+    date.getUTCMonth(),
+    date.getUTCDate(),
+    date.getUTCHours()
+  ),
+  minute: (date) => Date.UTC(
+    date.getUTCFullYear(),
+    date.getUTCMonth(),
+    date.getUTCDate(),
+    date.getUTCHours(),
+    date.getUTCMinutes()
+  ),
+  second: (date) => Date.UTC(
+    date.getUTCFullYear(),
+    date.getUTCMonth(),
+    date.getUTCDate(),
+    date.getUTCHours(),
+    date.getUTCMinutes(),
+    date.getUTCSeconds()
+  )
+};
+function groupValuesByDateColumn({
+  data,
+  valuesColumns,
+  joinOperation,
+  keysColumn,
+  groupType,
+  operation
+}) {
+  if (Array.isArray(data) && data.length === 0) {
+    return null;
+  }
+  const groupKeyFn = GROUP_KEY_FN_MAPPING[groupType];
+  if (!groupKeyFn) {
+    return null;
+  }
+  const groups = data.reduce((acc, item) => {
+    const value = item[keysColumn];
+    const formattedValue = new Date(value);
+    const groupKey = groupKeyFn(formattedValue);
+    if (!isNaN(groupKey)) {
+      let groupedValues = acc.get(groupKey);
+      if (!groupedValues) {
+        groupedValues = [];
+        acc.set(groupKey, groupedValues);
+      }
+      const aggregatedValue = aggregate(item, valuesColumns, joinOperation);
+      const isValid = aggregatedValue !== null && aggregatedValue !== void 0;
+      if (isValid) {
+        groupedValues.push(aggregatedValue);
+        acc.set(groupKey, groupedValues);
+      }
+    }
+    return acc;
+  }, /* @__PURE__ */ new Map());
+  const targetOperation = aggregationFunctions[operation];
+  return [...groups.entries()].map(([name, value]) => ({
+    name,
+    value: targetOperation(value)
+  })).sort((a, b) => a.name - b.name);
+}
+
+// src/operations/histogram.ts
+function histogram({
+  data,
+  valuesColumns,
+  joinOperation,
+  ticks,
+  operation
+}) {
+  if (Array.isArray(data) && data.length === 0) {
+    return [];
+  }
+  const binsContainer = [Number.MIN_SAFE_INTEGER, ...ticks].map(
+    (tick, index, arr) => ({
+      bin: index,
+      start: tick,
+      end: index === arr.length - 1 ? Number.MAX_SAFE_INTEGER : arr[index + 1],
+      values: []
+    })
+  );
+  data.forEach((feature2) => {
+    const featureValue = aggregate(
+      feature2,
+      valuesColumns,
+      joinOperation
+    );
+    const isValid = featureValue !== null && featureValue !== void 0;
+    if (!isValid) {
+      return;
+    }
+    const binContainer = binsContainer.find(
+      (bin) => bin.start <= featureValue && bin.end > featureValue
+    );
+    if (!binContainer) {
+      return;
+    }
+    binContainer.values.push(featureValue);
+  });
+  const targetOperation = aggregationFunctions[operation];
+  const transformedBins = binsContainer.map(
+    (binContainer) => binContainer.values
+  );
+  return transformedBins.map(
+    (values) => values.length ? targetOperation(values) : 0
+  );
+}
+
+// src/operations/scatterPlot.ts
+function scatterPlot({
+  data,
+  xAxisColumns,
+  xAxisJoinOperation,
+  yAxisColumns,
+  yAxisJoinOperation
+}) {
+  return data.reduce(
+    (acc, feature2) => {
+      const xValue = aggregate(
+        feature2,
+        xAxisColumns,
+        xAxisJoinOperation
+      );
+      const xIsValid = xValue !== null && xValue !== void 0;
+      const yValue = aggregate(
+        feature2,
+        yAxisColumns,
+        yAxisJoinOperation
+      );
+      const yIsValid = yValue !== null && yValue !== void 0;
+      if (xIsValid && yIsValid) {
+        acc.push([xValue, yValue]);
+      }
+      return acc;
+    },
+    []
+  );
+}
+
+// src/widget-sources/widget-tileset-source-impl.ts
+import { booleanEqual } from "@turf/boolean-equal";
+var WidgetTilesetSourceImpl = class extends WidgetSource {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_tiles", []);
+    __publicField(this, "_features", []);
+    __publicField(this, "_tileFeatureExtractOptions", {});
+    __publicField(this, "_tileFeatureExtractPreviousInputs", {});
+  }
+  /**
+   * Loads features as a list of tiles (typically provided by deck.gl).
+   * After tiles are loaded, {@link extractTileFeatures} must be called
+   * before computing statistics on the tiles.
+   */
+  loadTiles(tiles2) {
+    this._tiles = tiles2;
+    this._features.length = 0;
+  }
+  /** Configures options used to extract features from tiles. */
+  setTileFeatureExtractOptions(options) {
+    this._tileFeatureExtractOptions = options;
+    this._features.length = 0;
+  }
+  _extractTileFeatures(spatialFilter) {
+    const prevInputs = this._tileFeatureExtractPreviousInputs;
+    if (this._features.length && prevInputs.spatialFilter && booleanEqual(prevInputs.spatialFilter, spatialFilter)) {
+      return;
+    }
+    this._features = tileFeatures({
+      tiles: this._tiles,
+      tileFormat: this.props.tileFormat,
+      ...this._tileFeatureExtractOptions,
+      spatialFilter,
+      spatialDataColumn: this.props.spatialDataColumn,
+      spatialDataType: this.props.spatialDataType
+    });
+    prevInputs.spatialFilter = spatialFilter;
+  }
+  /**
+   * Loads features as GeoJSON (used for testing).
+   * @experimental
+   * @internal Not for public use. Spatial filters in other method calls will be ignored.
+   */
+  loadGeoJSON({
+    geojson,
+    spatialFilter
+  }) {
+    this._features = geojsonFeatures({
+      geojson,
+      spatialFilter,
+      ...this._tileFeatureExtractOptions
+    });
+    this._tileFeatureExtractPreviousInputs.spatialFilter = spatialFilter;
+  }
+  async getFeatures() {
+    throw new Error("getFeatures not supported for tilesets");
+  }
+  async getFormula({
+    column = "*",
+    operation = "count",
+    joinOperation,
+    filters,
+    filterOwner,
+    spatialFilter
+  }) {
+    if (operation === "custom") {
+      throw new Error("Custom aggregation not supported for tilesets");
+    }
+    if (column && column !== "*" || operation !== "count") {
+      assertColumn(this._features, column);
+    }
+    const filteredFeatures = this._getFilteredFeatures(
+      spatialFilter,
+      filters,
+      filterOwner
+    );
+    if (filteredFeatures.length === 0 && operation !== "count") {
+      return { value: null };
+    }
+    const targetOperation = aggregationFunctions[operation];
+    return {
+      value: targetOperation(filteredFeatures, column, joinOperation)
+    };
+  }
+  async getHistogram({
+    operation = "count",
+    ticks,
+    column,
+    joinOperation,
+    filters,
+    filterOwner,
+    spatialFilter
+  }) {
+    const filteredFeatures = this._getFilteredFeatures(
+      spatialFilter,
+      filters,
+      filterOwner
+    );
+    if (!this._features.length) {
+      return [];
+    }
+    assertColumn(this._features, column);
+    return histogram({
+      data: filteredFeatures,
+      valuesColumns: normalizeColumns(column),
+      joinOperation,
+      ticks,
+      operation
+    });
+  }
+  async getCategories({
+    column,
+    operation = "count",
+    operationColumn,
+    joinOperation,
+    filters,
+    filterOwner,
+    spatialFilter
+  }) {
+    const filteredFeatures = this._getFilteredFeatures(
+      spatialFilter,
+      filters,
+      filterOwner
+    );
+    if (!filteredFeatures.length) {
+      return [];
+    }
+    assertColumn(this._features, column, operationColumn);
+    const groups = groupValuesByColumn({
+      data: filteredFeatures,
+      valuesColumns: normalizeColumns(operationColumn || column),
+      joinOperation,
+      keysColumn: column,
+      operation
+    });
+    return groups || [];
+  }
+  async getScatter({
+    xAxisColumn,
+    yAxisColumn,
+    xAxisJoinOperation,
+    yAxisJoinOperation,
+    filters,
+    filterOwner,
+    spatialFilter
+  }) {
+    const filteredFeatures = this._getFilteredFeatures(
+      spatialFilter,
+      filters,
+      filterOwner
+    );
+    if (!filteredFeatures.length) {
+      return [];
+    }
+    assertColumn(this._features, xAxisColumn, yAxisColumn);
+    return scatterPlot({
+      data: filteredFeatures,
+      xAxisColumns: normalizeColumns(xAxisColumn),
+      xAxisJoinOperation,
+      yAxisColumns: normalizeColumns(yAxisColumn),
+      yAxisJoinOperation
+    });
+  }
+  async getTable({
+    columns,
+    searchFilterColumn,
+    searchFilterText,
+    sortBy,
+    sortDirection,
+    sortByColumnType,
+    offset = 0,
+    limit = 10,
+    filters,
+    filterOwner,
+    spatialFilter
+  }) {
+    let filteredFeatures = this._getFilteredFeatures(
+      spatialFilter,
+      filters,
+      filterOwner
+    );
+    if (!filteredFeatures.length) {
+      return { rows: [], totalCount: 0 };
+    }
+    if (searchFilterColumn && searchFilterText) {
+      filteredFeatures = filteredFeatures.filter(
+        (row) => row[searchFilterColumn] && String(row[searchFilterColumn]).toLowerCase().includes(String(searchFilterText).toLowerCase())
+      );
+    }
+    let rows = applySorting(filteredFeatures, {
+      sortBy,
+      sortByDirection: sortDirection,
+      sortByColumnType
+    });
+    const totalCount = rows.length;
+    rows = rows.slice(
+      Math.min(offset, totalCount),
+      Math.min(offset + limit, totalCount)
+    );
+    rows = rows.map((srcRow) => {
+      const dstRow = {};
+      for (const column of columns) {
+        dstRow[column] = srcRow[column];
+      }
+      return dstRow;
+    });
+    return { rows, totalCount };
+  }
+  async getTimeSeries({
+    column,
+    stepSize,
+    operation,
+    operationColumn,
+    joinOperation,
+    filters,
+    filterOwner,
+    spatialFilter
+  }) {
+    const filteredFeatures = this._getFilteredFeatures(
+      spatialFilter,
+      filters,
+      filterOwner
+    );
+    if (!filteredFeatures.length) {
+      return { rows: [] };
+    }
+    assertColumn(this._features, column, operationColumn);
+    const rows = groupValuesByDateColumn({
+      data: filteredFeatures,
+      valuesColumns: normalizeColumns(operationColumn || column),
+      keysColumn: column,
+      groupType: stepSize,
+      operation,
+      joinOperation
+    }) || [];
+    return { rows };
+  }
+  async getRange({
+    column,
+    filters,
+    filterOwner,
+    spatialFilter
+  }) {
+    assertColumn(this._features, column);
+    const filteredFeatures = this._getFilteredFeatures(
+      spatialFilter,
+      filters,
+      filterOwner
+    );
+    if (!this._features.length) {
+      return null;
+    }
+    return {
+      min: aggregationFunctions.min(filteredFeatures, column),
+      max: aggregationFunctions.max(filteredFeatures, column)
+    };
+  }
+  /****************************************************************************
+   * INTERNAL
+   */
+  _getFilteredFeatures(spatialFilter, filters, filterOwner) {
+    assert2(spatialFilter, "spatialFilter required for tilesets");
+    this._extractTileFeatures(spatialFilter);
+    return applyFilters(
+      this._features,
+      getApplicableFilters(filterOwner, filters || this.props.filters),
+      this.props.filtersLogicalOperator || "and"
+    );
+  }
+};
+function assertColumn(features, ...columnArgs) {
+  const columns = Array.from(new Set(columnArgs.map(normalizeColumns).flat()));
+  const featureKeys = Object.keys(features[0]);
+  const invalidColumns = columns.filter(
+    (column) => !featureKeys.includes(column)
+  );
+  if (invalidColumns.length) {
+    throw new InvalidColumnError(
+      `Missing column(s): ${invalidColumns.join(", ")}`
+    );
+  }
+}
+function normalizeColumns(columns) {
+  return Array.isArray(columns) ? columns : typeof columns === "string" ? [columns] : [];
+}
+
+// src/widget-sources/widget-tileset-source.ts
+var WidgetTilesetSource = class extends WidgetSource {
+  constructor(props) {
+    super(props);
+    __publicField(this, "_localImpl", null);
+    __publicField(this, "_workerImpl", null);
+    __publicField(this, "_workerEnabled");
+    __publicField(this, "_workerNextRequestId", 1);
+    this._workerEnabled = (props.widgetWorker ?? true) && true && typeof Worker !== "undefined";
+    if (!this._workerEnabled) {
+      this._localImpl = new WidgetTilesetSourceImpl(this.props);
+    }
+  }
+  destroy() {
+    this._localImpl?.destroy();
+    this._localImpl = null;
+    this._workerImpl?.terminate();
+    this._workerImpl = null;
+    super.destroy();
+  }
+  /////////////////////////////////////////////////////////////////////////////
+  // WEB WORKER MANAGEMENT
+  /**
+   * Returns an initialized Worker, to be reused for the lifecycle of this
+   * source instance.
+   */
+  _getWorker() {
+    if (this._workerImpl) {
+      return this._workerImpl;
+    }
+    this._workerImpl = new Worker(
+      new URL("@carto/api-client/worker", import.meta.url),
+      {
+        type: "module",
+        name: "cartowidgettileset"
+      }
+    );
+    this._workerImpl.postMessage({
+      method: "init" /* INIT */,
+      params: [this.props]
+    });
+    return this._workerImpl;
+  }
+  /** Executes a given method on the worker. */
+  _executeWorkerMethod(method, params, signal) {
+    if (!this._workerEnabled) {
+      return this._localImpl[method](...params);
+    }
+    const worker = this._getWorker();
+    const requestId = this._workerNextRequestId++;
+    const options = params[0];
+    if (options?.spatialIndexReferenceViewState) {
+      const { zoom, latitude, longitude } = options.spatialIndexReferenceViewState;
+      options.spatialIndexReferenceViewState = { zoom, latitude, longitude };
+    }
+    let resolve = null;
+    let reject = null;
+    function onMessage(e) {
+      const response = e.data;
+      if (response.requestId !== requestId) return;
+      if (signal?.aborted) {
+        reject(new Error(signal.reason));
+      } else if (response.ok) {
+        resolve(response.result);
+      } else {
+        reject(new Error(response.error));
+      }
+    }
+    function onAbort() {
+      reject(new Error(signal.reason));
+    }
+    worker.addEventListener("message", onMessage);
+    signal?.addEventListener("abort", onAbort);
+    const promise = new Promise((_resolve, _reject) => {
+      resolve = _resolve;
+      reject = _reject;
+      worker.postMessage({
+        requestId,
+        method,
+        params
+      });
+    });
+    void promise.finally(() => {
+      worker.removeEventListener("message", onMessage);
+      signal?.removeEventListener("abort", onAbort);
+    });
+    return promise;
+  }
+  /////////////////////////////////////////////////////////////////////////////
+  // DATA LOADING
+  /**
+   * Loads features as a list of tiles (typically provided by deck.gl).
+   * After tiles are loaded, {@link extractTileFeatures} must be called
+   * before computing statistics on the tiles.
+   */
+  loadTiles(tiles2) {
+    if (!this._workerEnabled) {
+      return this._localImpl.loadTiles(tiles2);
+    }
+    const worker = this._getWorker();
+    tiles2 = tiles2.map(({ id, bbox, data }) => ({
+      id,
+      bbox,
+      data
+    }));
+    worker.postMessage({
+      method: "loadTiles" /* LOAD_TILES */,
+      params: [tiles2]
+    });
+  }
+  /** Configures options used to extract features from tiles. */
+  setTileFeatureExtractOptions(options) {
+    if (!this._workerEnabled) {
+      return this._localImpl?.setTileFeatureExtractOptions(options);
+    }
+    const worker = this._getWorker();
+    worker.postMessage({
+      type: "setTileFeatureExtractOptions" /* SET_TILE_FEATURE_EXTRACT_OPTIONS */,
+      params: [options]
+    });
+  }
+  /**
+   * Loads features as GeoJSON (used for testing).
+   * @experimental
+   * @internal Not for public use. Spatial filters in other method calls will be ignored.
+   */
+  loadGeoJSON({
+    geojson,
+    spatialFilter
+  }) {
+    if (!this._workerEnabled) {
+      return this._localImpl.loadGeoJSON({ geojson, spatialFilter });
+    }
+    const worker = this._getWorker();
+    worker.postMessage({
+      method: "loadGeoJSON" /* LOAD_GEOJSON */,
+      params: [{ geojson, spatialFilter }]
+    });
+  }
+  /////////////////////////////////////////////////////////////////////////////
+  // WIDGETS API
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async getFeatures() {
+    throw new Error("getFeatures not supported for tilesets");
+  }
+  async getFormula({
+    signal,
+    ...options
+  }) {
+    return this._executeWorkerMethod("getFormula" /* GET_FORMULA */, [options], signal);
+  }
+  async getHistogram({
+    signal,
+    ...options
+  }) {
+    return this._executeWorkerMethod("getHistogram" /* GET_HISTOGRAM */, [options], signal);
+  }
+  async getCategories({
+    signal,
+    ...options
+  }) {
+    return this._executeWorkerMethod("getCategories" /* GET_CATEGORIES */, [options], signal);
+  }
+  async getScatter({
+    signal,
+    ...options
+  }) {
+    return this._executeWorkerMethod("getScatter" /* GET_SCATTER */, [options], signal);
+  }
+  async getTable({
+    signal,
+    ...options
+  }) {
+    return this._executeWorkerMethod("getTable" /* GET_TABLE */, [options], signal);
+  }
+  async getTimeSeries({
+    signal,
+    ...options
+  }) {
+    return this._executeWorkerMethod("getTimeSeries" /* GET_TIME_SERIES */, [options], signal);
+  }
+  async getRange({
+    signal,
+    ...options
+  }) {
+    return this._executeWorkerMethod("getRange" /* GET_RANGE */, [options], signal);
+  }
+};
+
+// src/sources/h3-query-source.ts
+var h3QuerySource = async function(options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
+    sqlQuery,
+    spatialDataColumn = "h3",
+    queryParameters,
+    filters
+  } = options;
+  const spatialDataType = "h3";
+  const urlParameters = {
+    aggregationExp,
+    spatialDataColumn,
+    spatialDataType,
+    q: sqlQuery
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource("query", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetQuerySource({
+        ...options,
+        // NOTE: Parameters with default values above must be explicitly passed here.
+        spatialDataColumn,
+        spatialDataType
+      })
+    })
+  );
+};
+
+// src/sources/h3-table-source.ts
+var h3TableSource = async function(options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
+    spatialDataColumn = "h3",
+    tableName,
+    filters
+  } = options;
+  const spatialDataType = "h3";
+  const urlParameters = {
+    aggregationExp,
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource("table", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetTableSource({
+        ...options,
+        // NOTE: Parameters with default values above must be explicitly passed here.
+        spatialDataColumn,
+        spatialDataType
+      })
+    })
+  );
+};
+
+// src/utils/getTileFormat.ts
+function getTileFormat(tilejson) {
+  const tileParams = new URL(tilejson.tiles[0]).searchParams;
+  return tileParams.get("formatTiles") === "mvt" ? "mvt" /* MVT */ : "binary" /* BINARY */;
+}
+
+// src/sources/h3-tileset-source.ts
+var h3TilesetSource = async function(options) {
+  const { tableName, spatialDataColumn = "h3" } = options;
+  const urlParameters = { name: tableName };
+  return baseSource("tileset", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetTilesetSource({
+        ...options,
+        tileFormat: getTileFormat(result),
+        spatialDataColumn,
+        spatialDataType: "h3"
+      })
+    })
+  );
+};
+
+// src/sources/raster-source.ts
+var rasterSource = async function(options) {
+  const { tableName, filters } = options;
+  const urlParameters = { name: tableName };
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource(
+    "raster",
+    options,
+    urlParameters
+  );
+};
+
+// src/sources/quadbin-query-source.ts
+var quadbinQuerySource = async function(options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
+    sqlQuery,
+    spatialDataColumn = "quadbin",
+    queryParameters,
+    filters
+  } = options;
+  const spatialDataType = "quadbin";
+  const urlParameters = {
+    aggregationExp,
+    q: sqlQuery,
+    spatialDataColumn,
+    spatialDataType
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource("query", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetQuerySource({
+        ...options,
+        // NOTE: Parameters with default values above must be explicitly passed here.
+        spatialDataColumn,
+        spatialDataType
+      })
+    })
+  );
+};
+
+// src/sources/quadbin-table-source.ts
+var quadbinTableSource = async function(options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
+    spatialDataColumn = "quadbin",
+    tableName,
+    filters
+  } = options;
+  const spatialDataType = "quadbin";
+  const urlParameters = {
+    aggregationExp,
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource("table", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetTableSource({
+        ...options,
+        // NOTE: Parameters with default values above must be explicitly passed here.
+        spatialDataColumn,
+        spatialDataType
+      })
+    })
+  );
+};
+
+// src/sources/quadbin-tileset-source.ts
+var quadbinTilesetSource = async function(options) {
+  const { tableName, spatialDataColumn = "quadbin" } = options;
+  const urlParameters = { name: tableName };
+  return baseSource("tileset", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetTilesetSource({
+        ...options,
+        tileFormat: getTileFormat(result),
+        spatialDataColumn,
+        spatialDataType: "quadbin"
+      })
+    })
+  );
+};
+
+// src/sources/vector-query-source.ts
+var vectorQuerySource = async function(options) {
+  const {
+    columns,
+    filters,
+    spatialDataColumn = DEFAULT_GEO_COLUMN,
+    sqlQuery,
+    tileResolution = DEFAULT_TILE_RESOLUTION,
+    queryParameters,
+    aggregationExp
+  } = options;
+  const spatialDataType = "geo";
+  const urlParameters = {
+    spatialDataColumn,
+    spatialDataType,
+    tileResolution: tileResolution.toString(),
+    q: sqlQuery
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(",");
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  if (aggregationExp) {
+    urlParameters.aggregationExp = aggregationExp;
+  }
+  return baseSource("query", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetQuerySource({
+        ...options,
+        // NOTE: Parameters with default values above must be explicitly passed here.
+        spatialDataColumn,
+        spatialDataType,
+        tileResolution
+      })
+    })
+  );
+};
+
+// src/sources/vector-table-source.ts
+var vectorTableSource = async function(options) {
+  const {
+    columns,
+    filters,
+    spatialDataColumn = DEFAULT_GEO_COLUMN,
+    tableName,
+    tileResolution = DEFAULT_TILE_RESOLUTION,
+    aggregationExp
+  } = options;
+  const spatialDataType = "geo";
+  const urlParameters = {
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType,
+    tileResolution: tileResolution.toString()
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(",");
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  if (aggregationExp) {
+    urlParameters.aggregationExp = aggregationExp;
+  }
+  return baseSource("table", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetTableSource({
+        ...options,
+        // NOTE: Parameters with default values above must be explicitly passed here.
+        spatialDataColumn,
+        spatialDataType,
+        tileResolution
+      })
+    })
+  );
+};
+
+// src/sources/vector-tileset-source.ts
+var vectorTilesetSource = async function(options) {
+  const { tableName, spatialDataColumn = DEFAULT_GEO_COLUMN } = options;
+  const urlParameters = { name: tableName };
+  return baseSource("tileset", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetTilesetSource({
+        ...options,
+        tileFormat: getTileFormat(result),
+        spatialDataColumn,
+        spatialDataType: "geo"
+      })
+    })
+  );
+};
+
+// src/api/query.ts
+var query = async function(options) {
+  const {
+    apiBaseUrl = SOURCE_DEFAULTS.apiBaseUrl,
+    clientId = SOURCE_DEFAULTS.clientId,
+    maxLengthURL = SOURCE_DEFAULTS.maxLengthURL,
+    localCache,
+    connectionName,
+    sqlQuery,
+    queryParameters
+  } = options;
+  const urlParameters = { q: sqlQuery };
+  if (queryParameters) {
+    urlParameters.queryParameters = JSON.stringify(queryParameters);
+  }
+  const baseUrl = buildQueryUrl({ apiBaseUrl, connectionName });
+  const headers = {
+    Authorization: `Bearer ${options.accessToken}`,
+    ...options.headers
+  };
+  const parameters = { client: clientId, ...urlParameters };
+  const errorContext = {
+    requestType: "SQL",
+    connection: options.connectionName,
+    type: "query",
+    source: JSON.stringify(parameters, void 0, 2)
+  };
+  return await requestWithParameters({
+    baseUrl,
+    parameters,
+    headers,
+    errorContext,
+    maxLengthURL,
+    localCache
+  });
+};
+export {
+  ApiVersion,
+  CartoAPIError,
+  DEFAULT_API_BASE_URL,
+  FEATURE_GEOM_PROPERTY,
+  FilterType,
+  Provider,
+  SOURCE_DEFAULTS,
+  SpatialIndex,
+  TileFormat,
+  WidgetQuerySource,
+  WidgetRemoteSource,
+  WidgetSource,
+  WidgetTableSource,
+  WidgetTilesetSource,
+  _buildFeatureFilter,
+  _getHexagonResolution,
+  addFilter,
+  aggregate,
+  aggregationFunctions,
+  applyFilters,
+  applySorting,
+  boundaryQuerySource,
+  boundaryTableSource,
+  buildBinaryFeatureFilter,
+  buildPublicMapUrl,
+  buildStatsUrl,
+  clearFilters,
+  createPolygonSpatialFilter,
+  createViewportSpatialFilter,
+  filterFunctions,
+  geojsonFeatures,
+  getClient,
+  getDataFilterExtensionProps,
+  getFilter,
+  groupValuesByColumn,
+  groupValuesByDateColumn,
+  h3QuerySource,
+  h3TableSource,
+  h3TilesetSource,
+  hasFilter,
+  histogram,
+  makeIntervalComplete,
+  quadbinQuerySource,
+  quadbinTableSource,
+  quadbinTilesetSource,
+  query,
+  rasterSource,
+  removeFilter,
+  requestWithParameters,
+  scatterPlot,
+  setClient,
+  tileFeatures,
+  tileFeaturesGeometries,
+  tileFeaturesSpatialIndex,
+  transformToTileCoords,
+  vectorQuerySource,
+  vectorTableSource,
+  vectorTilesetSource
+};
+//# sourceMappingURL=api-client.js.map