@carto/api-client 0.5.0-alpha.3 → 0.5.0-alpha.4

package/build/api-client.cjs

@@ -1,24 +1,25 @@
-var bboxClip = require('@turf/bbox-clip');
-var bboxPolygon = require('@turf/bbox-polygon');
-var union = require('@turf/union');
-var invariant = require('@turf/invariant');
-var helpers = require('@turf/helpers');
 var intersects = require('@turf/boolean-intersects');
+var bboxPolygon = require('@turf/bbox-polygon');
 var booleanWithin = require('@turf/boolean-within');
 var intersect = require('@turf/intersect');
+var helpers = require('@turf/helpers');
 var quadbin = require('quadbin');
+var bboxClip = require('@turf/bbox-clip');
 var h3Js = require('h3-js');
+var union = require('@turf/union');
+var invariant = require('@turf/invariant');
+var booleanEqual = require('@turf/boolean-equal');
 
 /**
  * @internal
- * @internalRemarks Source: @carto/react-core, @carto/constants, @deck.gl/carto
+ * @privateRemarks Source: @carto/react-core, @carto/constants, @deck.gl/carto
  */
 let client = 'deck-gl-carto';
 /**
  * Returns current client ID, used to categorize API requests. For internal use only.
  *
  * @internal
- * @internalRemarks Source: @carto/react-core
+ * @privateRemarks Source: @carto/react-core
  */
 function getClient() {
   return client;
@@ -27,7 +28,7 @@ function getClient() {
  * Sets current client ID, used to categorize API requests. For internal use only.
  *
  * @internal
- * @internalRemarks Source: @carto/react-core
+ * @privateRemarks Source: @carto/react-core
  */
 function setClient(c) {
   client = c;
@@ -45,7 +46,7 @@ function setClient(c) {
  * };
  * ```
  *
- * @internalRemarks Source: @carto/react-api, @deck.gl/carto
+ * @privateRemarks Source: @carto/react-api, @deck.gl/carto
  */
 exports.FilterType = void 0;
 (function (FilterType) {
@@ -57,16 +58,16 @@ exports.FilterType = void 0;
   FilterType["TIME"] = "time";
   FilterType["STRING_SEARCH"] = "stringSearch";
 })(exports.FilterType || (exports.FilterType = {}));
-/** @internalRemarks Source: @carto/constants */
+/** @privateRemarks Source: @carto/constants */
 exports.ApiVersion = void 0;
 (function (ApiVersion) {
   ApiVersion["V1"] = "v1";
   ApiVersion["V2"] = "v2";
   ApiVersion["V3"] = "v3";
 })(exports.ApiVersion || (exports.ApiVersion = {}));
-/** @internalRemarks Source: @carto/constants, @deck.gl/carto */
+/** @privateRemarks Source: @carto/constants, @deck.gl/carto */
 const DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 exports.TileFormat = void 0;
 (function (TileFormat) {
   TileFormat["MVT"] = "mvt";
@@ -74,14 +75,14 @@ exports.TileFormat = void 0;
   TileFormat["GEOJSON"] = "geojson";
   TileFormat["BINARY"] = "binary";
 })(exports.TileFormat || (exports.TileFormat = {}));
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 exports.SpatialIndex = void 0;
 (function (SpatialIndex) {
   SpatialIndex["H3"] = "h3";
   SpatialIndex["S2"] = "s2";
   SpatialIndex["QUADBIN"] = "quadbin";
 })(exports.SpatialIndex || (exports.SpatialIndex = {}));
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 exports.Provider = void 0;
 (function (Provider) {
   Provider["BIGQUERY"] = "bigquery";
@@ -92,2312 +93,2438 @@ exports.Provider = void 0;
   Provider["DATABRICKS_REST"] = "databricksRest";
 })(exports.Provider || (exports.Provider = {}));
 
-const FILTER_TYPES = new Set(Object.values(exports.FilterType));
-const isFilterType = type => FILTER_TYPES.has(type);
-/**
- * @privateRemarks Source: @carto/react-widgets
- * @internal
- */
-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][type] = filter;
-      }
+function makeIntervalComplete(intervals) {
+  return intervals.map(val => {
+    if (val[0] === undefined || val[0] === null) {
+      return [Number.MIN_SAFE_INTEGER, val[1]];
     }
-  }
-  return applicableFilters;
+    if (val[1] === undefined || val[1] === null) {
+      return [val[0], Number.MAX_SAFE_INTEGER];
+    }
+    return val;
+  });
 }
-/**
- * Due to each data warehouse having its own behavior with columns,
- * we need to normalize them and transform every key to lowercase.
- *
- * @internalRemarks Source: @carto/react-widgets
- * @internal
- */
-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, _ref) => {
-    let [key, value] = _ref;
-    acc[key.toLowerCase()] = typeof value === 'object' && value ? normalizeObjectKeys(value) : value;
-    return acc;
-  }, {});
+
+const filterFunctions = {
+  [exports.FilterType.IN]: filterIn,
+  [exports.FilterType.BETWEEN]: filterBetween,
+  [exports.FilterType.TIME]: filterTime,
+  [exports.FilterType.CLOSED_OPEN]: filterClosedOpen,
+  [exports.FilterType.STRING_SEARCH]: filterStringSearch
+};
+function filterIn(filterValues, featureValue) {
+  return filterValues.includes(featureValue);
 }
-/** @internalRemarks Source: @carto/react-core */
-function assert$1(condition, message) {
-  if (!condition) {
-    throw new Error(message);
-  }
+// FilterTypes.BETWEEN
+function filterBetween(filterValues, featureValue) {
+  const checkRange = range => {
+    const [lowerBound, upperBound] = range;
+    return featureValue >= lowerBound && featureValue <= upperBound;
+  };
+  return makeIntervalComplete(filterValues).some(checkRange);
 }
-/**
- * @internalRemarks Source: @carto/react-core
- * @internal
- */
-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);
+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.`);
   }
 }
-InvalidColumnError.NAME = 'InvalidColumnError';
-function isEmptyObject(object) {
-  for (const _ in object) {
-    return false;
+// FilterTypes.CLOSED_OPEN
+function filterClosedOpen(filterValues, featureValue) {
+  const checkRange = range => {
+    const [lowerBound, upperBound] = range;
+    return featureValue >= lowerBound && featureValue < upperBound;
+  };
+  return makeIntervalComplete(filterValues).some(checkRange);
+}
+// FilterTypes.STRING_SEARCH
+function filterStringSearch(filterValues, featureValue, params) {
+  if (params === void 0) {
+    params = {};
   }
-  return true;
+  const normalizedFeatureValue = normalize(featureValue, params);
+  const stringRegExp = params.useRegExp ? filterValues : filterValues.map(filterValue => {
+    let stringRegExp = escapeRegExp(normalize(filterValue, params));
+    if (params.mustStart) stringRegExp = `^${stringRegExp}`;
+    if (params.mustEnd) stringRegExp = `${stringRegExp}$`;
+    return stringRegExp;
+  });
+  const regex = new RegExp(stringRegExp.join('|'), params.caseSensitive ? 'g' : 'gi');
+  return !!normalizedFeatureValue.match(regex);
+}
+// Aux
+const specialCharRegExp = /[.*+?^${}()|[\]\\]/g;
+const 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;
 }
-/** @internal */
-const isObject = x => x !== null && typeof x === 'object';
-/** @internal */
-const isPureObject = x => isObject(x) && x.constructor === {}.constructor;
 
+const LOGICAL_OPERATOR_METHODS = {
+  and: 'every',
+  or: 'some'
+};
+function passesFilter(columns, filters, feature, filtersLogicalOperator) {
+  const method = LOGICAL_OPERATOR_METHODS[filtersLogicalOperator];
+  return columns[method](column => {
+    const columnFilters = filters[column];
+    const columnFilterTypes = Object.keys(columnFilters);
+    if (!feature || feature[column] === null || feature[column] === undefined) {
+      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, feature[column], columnFilters[filter].params);
+    });
+  });
+}
 /**
- * Adds a {@link Filter} to the filter set. Any previous filters with the same
- * `column` and `type` will be replaced.
+ * @internal
+ * @privateRemarks Exported for use in @deck.gl/carto's getDataFilterExtensionProps.
  */
-function addFilter(filters, _ref) {
+function _buildFeatureFilter(_ref) {
   let {
-    column,
-    type,
-    values,
-    owner
+    filters = {},
+    type = 'boolean',
+    filtersLogicalOperator = 'and'
   } = _ref;
-  if (!filters[column]) {
-    filters[column] = {};
+  const columns = Object.keys(filters);
+  if (!columns.length) {
+    return () => type === 'number' ? 1 : true;
   }
-  const filter = {
-    values,
-    owner
+  return feature => {
+    const f = feature.properties || feature;
+    const featurePassesFilter = passesFilter(columns, filters, f, filtersLogicalOperator);
+    return type === 'number' ? Number(featurePassesFilter) : featurePassesFilter;
   };
-  filters[column][type] = filter;
-  return filters;
 }
 /**
- * Removes one or more {@link Filter filters} from the filter set. If only
- * `column` is specified, then all filters on that column are removed. If both
- * `column` and `owner` are specified, then only filters for that column
- * associated with the owner are removed.
+ * Apply certain filters to a collection of features.
+ * @internal
  */
-function removeFilter(filters, _ref2) {
-  let {
-    column,
-    owner
-  } = _ref2;
-  const filter = filters[column];
-  if (!filter) {
-    return filters;
-  }
-  if (owner) {
-    for (const type of Object.values(exports.FilterType)) {
-      if (owner === filter[type]?.owner) {
-        delete filter[type];
-      }
-    }
-  }
-  if (!owner || isEmptyObject(filter)) {
-    delete filters[column];
-  }
-  return filters;
+function applyFilters(features, filters, filtersLogicalOperator) {
+  return Object.keys(filters).length ? features.filter(_buildFeatureFilter({
+    filters,
+    filtersLogicalOperator
+  })) : features;
 }
 /**
- * Clears all {@link Filter filters} from the filter set.
+ * Binary.
+ * @internal
  */
-function clearFilters(filters) {
-  for (const column of Object.keys(filters)) {
-    delete filters[column];
+function buildBinaryFeatureFilter(_ref2) {
+  let {
+    filters = {}
+  } = _ref2;
+  const columns = Object.keys(filters);
+  if (!columns.length) {
+    return () => 1;
   }
-  return filters;
+  return (featureIdIdx, binaryData) => passesFilterUsingBinary(columns, filters, featureIdIdx, binaryData);
 }
-function hasFilter(filters, _ref3) {
+function getValueFromNumericProps(featureIdIdx, binaryData, _ref3) {
   let {
-    column,
-    owner
+    column
   } = _ref3;
-  const filter = filters[column];
-  if (!filter) {
-    return false;
-  }
-  if (!owner) {
-    return true;
-  }
-  for (const type of Object.values(exports.FilterType)) {
-    if (owner === filter[type]?.owner) {
-      return true;
-    }
-  }
-  return false;
+  return binaryData.numericProps?.[column]?.value[featureIdIdx];
 }
-function getFilter(filters, _ref4) {
+function getValueFromProperties(featureIdIdx, binaryData, _ref4) {
   let {
-    column,
-    type,
-    owner
+    column
   } = _ref4;
-  const filter = filters[column];
-  if (!filter) {
-    return null;
-  }
-  if (!owner || owner === filter[type]?.owner) {
-    return filter[type] || null;
-  }
-  return null;
+  const propertyIdx = binaryData.featureIds.value[featureIdIdx];
+  return binaryData.properties[propertyIdx]?.[column];
+}
+const 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(_ref5 => {
+      let [type, {
+        values
+      }] = _ref5;
+      const filterFn = filterFunctions[type];
+      if (!filterFn) {
+        throw new Error(`"${type}" filter is not implemented.`);
+      }
+      if (!values) return 0;
+      const featureValue = getFeatureValue(featureIdIdx, binaryData, {
+        type: type,
+        column,
+        values
+      });
+      if (featureValue === undefined || featureValue === null) return 0;
+      return filterFn(values, featureValue);
+    });
+  });
+}
+
+function geojsonFeatures(_ref) {
+  let {
+    geojson,
+    spatialFilter,
+    uniqueIdProperty
+  } = _ref;
+  let uniqueIdx = 0;
+  const map = new Map();
+  if (!spatialFilter) {
+    return [];
+  }
+  for (const feature of geojson.features) {
+    const uniqueId = uniqueIdProperty ? feature.properties[uniqueIdProperty] : ++uniqueIdx;
+    if (!map.has(uniqueId) && intersects(spatialFilter, feature)) {
+      map.set(uniqueId, feature.properties);
+    }
+  }
+  return Array.from(map.values());
 }
 
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const DEFAULT_CONFIG = {
+  EPSILON: 1e-12,
+  debug: false,
+  precision: 4,
+  printTypes: false,
+  printDegrees: false,
+  printRowMajor: true,
+  _cartographicRadians: false
+};
+// Configuration is truly global as of v3.6 to ensure single config even if multiple copies of math.gl
+// Multiple copies of config can be quite tricky to debug...
+globalThis.mathgl = globalThis.mathgl || {
+  config: {
+    ...DEFAULT_CONFIG
+  }
+};
 /**
- * Returns a {@link SpatialFilter} for a given viewport, typically obtained
- * from deck.gl's `viewport.getBounds()` method ([west, south, east, north]).
- * If the viewport covers the entire world (to some margin of error in Web
- * Mercator space), `undefined` is returned instead.
- *
- * If the viewport extends beyond longitude range [-180, +180], the polygon
- * may be reformatted for compatibility with CARTO APIs.
+ * Check if value is an "array"
+ * Returns `true` if value is either an array or a typed array
+ * Note: returns `false` for `ArrayBuffer` and `DataView` instances
+ * @note isTypedArray and isNumericArray are often more useful in TypeScript
  */
-function createViewportSpatialFilter(viewport) {
-  if (_isGlobalViewport(viewport)) {
-    return;
+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;
+}
+
+// Replacement for the external assert method to reduce bundle size
+// Note: We don't use the second "message" argument in calling code,
+// so no need to support it here
+function assert$1(condition, message) {
+  if (!condition) {
+    throw new Error(message || '@math.gl/web-mercator: assertion failed.');
   }
-  return createPolygonSpatialFilter(bboxPolygon(viewport).geometry);
 }
+
+// TODO - THE UTILITIES IN THIS FILE SHOULD BE IMPORTED FROM WEB-MERCATOR-VIEWPORT MODULE
+// CONSTANTS
+const PI = Math.PI;
+const PI_4 = PI / 4;
+const DEGREES_TO_RADIANS = PI / 180;
+const RADIANS_TO_DEGREES = 180 / PI;
+const TILE_SIZE = 512;
 /**
- * Returns a {@link SpatialFilter} for a given {@link Polygon} or
- * {@link MultiPolygon}. If the polygon(s) extend outside longitude
- * range [-180, +180], the result may be reformatted for compatibility
- * with CARTO APIs.
+ * Project [lng,lat] on sphere onto [x,y] on 512*512 Mercator Zoom 0 tile.
+ * Performs the nonlinear part of the web mercator projection.
+ * Remaining projection is done with 4x4 matrices which also handles
+ * perspective.
+ *
+ * @param lngLat - [lng, lat] coordinates
+ *   Specifies a point on the sphere to project onto the map.
+ * @return [x,y] coordinates.
  */
-function createPolygonSpatialFilter(spatialFilter) {
-  return spatialFilter && _normalizeGeometry(spatialFilter) || undefined;
+function lngLatToWorld(lngLat) {
+  const [lng, lat] = lngLat;
+  assert$1(Number.isFinite(lng));
+  assert$1(Number.isFinite(lat) && lat >= -90 && lat <= 90, 'invalid latitude');
+  const lambda2 = lng * DEGREES_TO_RADIANS;
+  const phi2 = lat * DEGREES_TO_RADIANS;
+  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];
 }
 /**
- * Check if a viewport is large enough to represent a global coverage.
- * In this case the spatial filter parameter for widget calculation is removed.
+ * Unproject world point [x,y] on map onto {lat, lon} on sphere
  *
- * @internalRemarks Source: @carto/react-core
+ * @param xy - array with [x,y] members
+ *  representing point on projected map plane
+ * @return - array with [x,y] of point on sphere.
+ *   Has toArray method if you need a GeoJSON Array.
+ *   Per cartographic tradition, lat and lon are specified as degrees.
  */
-function _isGlobalViewport(viewport) {
-  const [minx, miny, maxx, maxy] = viewport;
-  return maxx - minx > 179.5 * 2 && maxy - miny > 85.05 * 2;
+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_DEGREES, phi2 * RADIANS_TO_DEGREES];
 }
+
+const TRANSFORM_FN$1 = {
+  Point: transformPoint$1,
+  MultiPoint: transformMultiPoint$1,
+  LineString: transformLineString$1,
+  MultiLineString: transformMultiLineString$1,
+  Polygon: transformPolygon$1,
+  MultiPolygon: transformMultiPolygon$1
+};
 /**
- * Normalized a geometry, coming from a mask or a viewport. The parts
- * spanning outside longitude range [-180, +180] are clipped and "folded"
- * back to the valid range and unioned to the polygons inide that range.
- *
- * It results in a Polygon or MultiPolygon strictly inside the validity range.
+ * Transform WGS84 coordinates to tile coords.
+ * It's the inverse of deck.gl coordinate-transform (https://github.com/visgl/deck.gl/blob/master/modules/geo-layers/src/mvt-layer/coordinate-transform.js)
  *
- * @internalRemarks Source: @carto/react-core
+ * @param geometry - any valid geojson geometry
+ * @param bbox - geojson bbox
  */
-function _normalizeGeometry(geometry) {
-  const WORLD = [-180, -90, +180, +90];
-  const worldClip = _clean(bboxClip(geometry, WORLD).geometry);
-  const geometryTxWest = _tx(geometry, 360);
-  const geometryTxEast = _tx(geometry, -360);
-  let result = worldClip;
-  if (result && geometryTxWest) {
-    const worldWestClip = _clean(bboxClip(geometryTxWest, WORLD).geometry);
-    if (worldWestClip) {
-      const collection = helpers.featureCollection([helpers.feature(result), helpers.feature(worldWestClip)]);
-      const merged = union(collection);
-      result = merged ? _clean(merged.geometry) : result;
-    }
-  }
-  if (result && geometryTxEast) {
-    const worldEastClip = _clean(bboxClip(geometryTxEast, WORLD).geometry);
-    if (worldEastClip) {
-      const collection = helpers.featureCollection([helpers.feature(result), helpers.feature(worldEastClip)]);
-      const merged = union(collection);
-      result = merged ? _clean(merged.geometry) : result;
-    }
+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');
   }
-  return result;
+  const transformFn = TRANSFORM_FN$1[geometry.type];
+  const coordinates = transformFn(geometry.coordinates, projectedBbox);
+  return {
+    ...geometry,
+    coordinates
+  };
 }
-/** @internalRemarks Source: @carto/react-core */
-function _cleanPolygonCoords(cc) {
-  const coords = cc.filter(c => c.length > 0);
-  return coords.length > 0 ? coords : null;
+function transformPoint$1(_ref, _ref2) {
+  let [pointX, pointY] = _ref;
+  let [nw, se] = _ref2;
+  const x = inverseLerp(nw[0], se[0], pointX);
+  const y = inverseLerp(nw[1], se[1], pointY);
+  return [x, y];
 }
-/** @internalRemarks Source: @carto/react-core */
-function _cleanMultiPolygonCoords(ccc) {
-  const coords = ccc.map(_cleanPolygonCoords).filter(cc => cc);
-  return coords.length > 0 ? coords : null;
+function getPoints$1(geometry, bbox) {
+  return geometry.map(g => transformPoint$1(projectFlat(g), bbox));
 }
-/** @internalRemarks Source: @carto/react-core */
-function _clean(geometry) {
-  if (!geometry) {
-    return null;
-  }
-  if (_isPolygon(geometry)) {
-    const coords = _cleanPolygonCoords(geometry.coordinates);
-    return coords ? helpers.polygon(coords).geometry : null;
-  }
-  if (_isMultiPolygon(geometry)) {
-    const coords = _cleanMultiPolygonCoords(geometry.coordinates);
-    return coords ? helpers.multiPolygon(coords).geometry : null;
-  }
-  return null;
+function transformMultiPoint$1(multiPoint, bbox) {
+  return getPoints$1(multiPoint, bbox);
 }
-/** @internalRemarks Source: @carto/react-core */
-function _txContourCoords(cc, distance) {
-  return cc.map(c => [c[0] + distance, c[1]]);
+function transformLineString$1(line, bbox) {
+  return getPoints$1(line, bbox);
 }
-/** @internalRemarks Source: @carto/react-core */
-function _txPolygonCoords(ccc, distance) {
-  return ccc.map(cc => _txContourCoords(cc, distance));
+function transformMultiLineString$1(multiLineString, bbox) {
+  return multiLineString.map(lineString => transformLineString$1(lineString, bbox));
 }
-/** @internalRemarks Source: @carto/react-core */
-function _txMultiPolygonCoords(cccc, distance) {
-  return cccc.map(ccc => _txPolygonCoords(ccc, distance));
+function transformPolygon$1(polygon, bbox) {
+  return polygon.map(polygonRing => getPoints$1(polygonRing, bbox));
 }
-/** @internalRemarks Source: @carto/react-core */
-function _tx(geometry, distance) {
-  if (geometry && invariant.getType(geometry) === 'Polygon') {
-    const coords = _txPolygonCoords(geometry.coordinates, distance);
-    return helpers.polygon(coords).geometry;
-  } else if (geometry && invariant.getType(geometry) === 'MultiPolygon') {
-    const coords = _txMultiPolygonCoords(geometry.coordinates, distance);
-    return helpers.multiPolygon(coords).geometry;
-  } else {
-    return null;
-  }
+function transformMultiPolygon$1(multiPolygon, bbox) {
+  return multiPolygon.map(polygon => transformPolygon$1(polygon, bbox));
 }
-function _isPolygon(geometry) {
-  return invariant.getType(geometry) === 'Polygon';
+function projectFlat(xyz) {
+  return lngLatToWorld(xyz);
 }
-function _isMultiPolygon(geometry) {
-  return invariant.getType(geometry) === 'MultiPolygon';
+function inverseLerp(a, b, x) {
+  return (x - a) / (b - a);
 }
 
+const TRANSFORM_FN = {
+  Point: transformPoint,
+  MultiPoint: transformMultiPoint,
+  LineString: transformLineString,
+  MultiLineString: transformMultiLineString,
+  Polygon: transformPolygon,
+  MultiPolygon: transformMultiPolygon
+};
 /**
- * Current version of @carto/api-client.
- * @internal
- */
-/** @internal */
-const V3_MINOR_VERSION = '3.4';
-/** @internalRemarks Source: @carto/constants, @deck.gl/carto */
-const DEFAULT_GEO_COLUMN = 'geom';
-/**
- * Fastly default limit is 8192; leave some padding.
- * @internalRemarks Source: @deck.gl/carto
- */
-const DEFAULT_MAX_LENGTH_URL = 7000;
-/** @internalRemarks Source: @deck.gl/carto */
-const DEFAULT_TILE_RESOLUTION = 0.5;
-/**
- * @internalRemarks Source: @deck.gl/carto
- * @internal
- */
-const DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
-/**
- * @internalRemarks Source: @deck.gl/carto
- * @internal
+ * Transform tile coords to WGS84 coordinates.
+ *
+ * @param geometry - any valid geojson geometry
+ * @param bbox - geojson bbox
  */
-const DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
-
-// deck.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-function joinPath() {
-  return [].slice.call(arguments).map(part => part.endsWith('/') ? part.slice(0, -1) : part).join('/');
+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_FN[geometry.type];
+  const coordinates = transformFn(geometry.coordinates, projectedBbox);
+  return {
+    ...geometry,
+    coordinates
+  };
 }
-function buildV3Path(apiBaseUrl, version, endpoint) {
-  return joinPath(apiBaseUrl, version, endpoint, ...[].slice.call(arguments, 3));
+function transformPoint(_ref, _ref2) {
+  let [pointX, pointY] = _ref;
+  let [nw, se] = _ref2;
+  const x = lerp(nw[0], se[0], pointX);
+  const y = lerp(nw[1], se[1], pointY);
+  return worldToLngLat([x, y]);
 }
-/** @internal Required by fetchMap(). */
-function buildPublicMapUrl(_ref) {
-  let {
-    apiBaseUrl,
-    cartoMapId
-  } = _ref;
-  return buildV3Path(apiBaseUrl, 'v3', 'maps', 'public', cartoMapId);
+function getPoints(geometry, bbox) {
+  return geometry.map(g => transformPoint(g, bbox));
 }
-/** @internal Required by fetchMap(). */
-function buildStatsUrl(_ref2) {
-  let {
-    attribute,
-    apiBaseUrl,
-    connectionName,
-    source,
-    type
-  } = _ref2;
-  if (type === 'query') {
-    return buildV3Path(apiBaseUrl, 'v3', 'stats', connectionName, attribute);
-  }
-  // type === 'table'
-  return buildV3Path(apiBaseUrl, 'v3', 'stats', connectionName, source, attribute);
+function transformMultiPoint(multiPoint, bbox) {
+  return getPoints(multiPoint, bbox);
 }
-function buildSourceUrl(_ref3) {
-  let {
-    apiBaseUrl,
-    connectionName,
-    endpoint
-  } = _ref3;
-  return buildV3Path(apiBaseUrl, 'v3', 'maps', connectionName, endpoint);
+function transformLineString(line, bbox) {
+  return getPoints(line, bbox);
 }
-function buildQueryUrl(_ref4) {
-  let {
-    apiBaseUrl,
-    connectionName
-  } = _ref4;
-  return buildV3Path(apiBaseUrl, 'v3', 'sql', connectionName, 'query');
+function transformMultiLineString(multiLineString, bbox) {
+  return multiLineString.map(lineString => transformLineString(lineString, bbox));
 }
-
-// deck.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-/**
- *
- * Custom error for reported errors in CARTO Maps API.
- * Provides useful debugging information in console and context for applications.
- *
- */
-class CartoAPIError 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 += `\n${responseString}`;
-    for (const key of Object.keys(errorContext)) {
-      if (key === 'requestType') continue;
-      message += `\n${formatErrorKey(key)}: ${errorContext[key]}`;
-    }
-    message += '\n';
-    super(message);
-    /** Source error from server */
-    this.error = void 0;
-    /** Context (API call & parameters) in which error occured */
-    this.errorContext = void 0;
-    /** Response from server */
-    this.response = void 0;
-    /** JSON Response from server */
-    this.responseJson = void 0;
-    this.name = 'CartoAPIError';
-    this.response = response;
-    this.responseJson = responseJson;
-    this.error = error;
-    this.errorContext = errorContext;
-  }
+function transformPolygon(polygon, bbox) {
+  return polygon.map(polygonRing => getPoints(polygonRing, bbox));
 }
-/**
- * Converts camelCase to Camel Case
- */
-function formatErrorKey(key) {
-  return key.replace(/([A-Z])/g, ' $1').replace(/^./, s => s.toUpperCase());
+function transformMultiPolygon(multiPolygon, bbox) {
+  return multiPolygon.map(polygon => transformPolygon(polygon, bbox));
 }
 
-// deck.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-const requestWithParameters = function (_ref) {
+const FEATURE_GEOM_PROPERTY = '__geomValue';
+function tileFeaturesGeometries(_ref) {
   let {
-    baseUrl,
-    parameters = {},
-    headers: customHeaders = {},
-    errorContext,
-    maxLengthURL = DEFAULT_MAX_LENGTH_URL,
-    localCache
+    tiles,
+    tileFormat,
+    spatialFilter,
+    uniqueIdProperty,
+    options
   } = _ref;
-  try {
-    // Parameters added to all requests issued with `requestWithParameters()`.
-    // These parameters override parameters already in the base URL, but not
-    // user-provided parameters.
-    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 Promise.resolve(REQUEST_CACHE.get(key));
+  const map = new Map();
+  for (const tile of tiles) {
+    // Discard if it's not a visible tile (only check false value, not undefined)
+    // or tile has not data
+    if (tile.isVisible === false || !tile.data) {
+      continue;
     }
-    const url = createURLWithParameters(baseUrl, parameters);
-    const headers = {
-      ...DEFAULT_HEADERS,
-      ...customHeaders
+    const bbox = [tile.bbox.west, tile.bbox.south, tile.bbox.east, tile.bbox.north];
+    const bboxToGeom = bboxPolygon(bbox);
+    const tileIsFullyVisible = booleanWithin(bboxToGeom, spatialFilter);
+    // Clip the geometry to intersect with the tile
+    const spatialFilterFeature = {
+      type: 'Feature',
+      geometry: spatialFilter,
+      properties: {}
     };
-    /* global fetch */
-    const fetchPromise = url.length > maxLengthURL ? fetch(baseUrl, {
-      method: 'POST',
-      body: JSON.stringify(parameters),
-      headers
-    }) : fetch(url, {
-      headers
+    const clippedGeometryToIntersect = intersect(helpers.featureCollection([bboxToGeom, spatialFilterFeature]));
+    if (!clippedGeometryToIntersect) {
+      continue;
+    }
+    // We assume that MVT tileFormat uses local coordinates so we transform the geometry to intersect to tile coordinates [0..1],
+    // while in the case of 'geojson' or binary, the geometries are already in WGS84
+    const transformedGeometryToIntersect = tileFormat === exports.TileFormat.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
     });
-    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);
+    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
     });
-    if (canStoreInCache) {
-      REQUEST_CACHE.set(key, jsonPromise);
-    }
-    return Promise.resolve(jsonPromise);
-  } catch (e) {
-    return Promise.reject(e);
   }
-};
-const DEFAULT_HEADERS = {
-  Accept: 'application/json',
-  'Content-Type': 'application/json'
-};
-const DEFAULT_REQUEST_CACHE = new Map();
-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
+  return Array.from(map.values());
+}
+function processTileFeatureProperties(_ref2) {
+  let {
+    map,
+    data,
+    startIndex,
+    endIndex,
+    type,
+    bbox,
+    tileFormat,
+    uniqueIdProperty,
+    storeGeometry,
+    geometryIntersection
+  } = _ref2;
+  const tileProps = getPropertiesFromTile(data, startIndex);
+  const uniquePropertyValue = getUniquePropertyValue(tileProps, uniqueIdProperty, map);
+  if (!uniquePropertyValue || map.has(uniquePropertyValue)) {
+    return;
+  }
+  let geometry = null;
+  // Only calculate geometry if necessary
+  if (storeGeometry || geometryIntersection) {
+    const {
+      positions
+    } = data;
+    const ringCoordinates = getRingCoordinatesFor(startIndex, endIndex, positions);
+    geometry = getFeatureByType(ringCoordinates, type);
+  }
+  // If intersection is required, check before proceeding
+  if (geometry && geometryIntersection && !intersects(geometry, geometryIntersection)) {
+    return;
+  }
+  const properties = parseProperties(tileProps);
+  // Only save geometry if necessary
+  if (storeGeometry && geometry) {
+    properties[FEATURE_GEOM_PROPERTY] = tileFormat === exports.TileFormat.MVT ? transformTileCoordsToWGS84(geometry, bbox) : geometry;
+  }
+  map.set(uniquePropertyValue, properties);
+}
+function addIntersectedFeaturesInTile(_ref3) {
+  let {
+    map,
+    data,
+    geometryIntersection,
+    type,
+    bbox,
+    tileFormat,
+    uniqueIdProperty,
+    options
+  } = _ref3;
+  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':
+      // @ts-expect-error Missing or changed types?
+      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 createCacheKey(baseUrl, parameters, headers) {
-  const parameterEntries = Object.entries(parameters).sort((_ref2, _ref3) => {
-    let [a] = _ref2;
-    let [b] = _ref3;
-    return a > b ? 1 : -1;
-  });
-  const headerEntries = Object.entries(headers).sort((_ref4, _ref5) => {
-    let [a] = _ref4;
-    let [b] = _ref5;
-    return a > b ? 1 : -1;
-  });
-  return JSON.stringify({
-    baseUrl,
-    parameters: parameterEntries,
-    headers: headerEntries
-  });
+function parseProperties(tileProps) {
+  const {
+    properties,
+    numericProps
+  } = tileProps;
+  return Object.assign({}, properties, numericProps);
 }
-/**
- * Appends query string parameters to a URL. Existing URL parameters are kept,
- * unless there is a conflict, in which case the new parameters override
- * those already in the URL.
- */
-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());
-    }
+function getUniquePropertyValue(tileProps, uniqueIdProperty, map) {
+  if (uniqueIdProperty) {
+    return getValueFromTileProps(tileProps, uniqueIdProperty);
   }
-  return baseUrl.toString();
+  if (tileProps.uniqueId) {
+    return tileProps.uniqueId;
+  }
+  const artificialId = map.size + 1; // a counter, assumed as a valid new id
+  return getValueFromTileProps(tileProps, 'cartodb_id') || getValueFromTileProps(tileProps, 'geoid') || artificialId;
 }
-/**
- * Deletes query string parameters from a URL.
- */
-function excludeURLParameters(baseUrlString, parameters) {
-  const baseUrl = new URL(baseUrlString);
-  for (const param of parameters) {
-    if (baseUrl.searchParams.has(param)) {
-      baseUrl.searchParams.delete(param);
-    }
+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');
   }
-  return baseUrl.toString();
 }
-
-// deck.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-const baseSource = function (endpoint, options, urlParameters) {
-  try {
-    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, undefined, 2)
-    };
-    return Promise.resolve(requestWithParameters({
-      baseUrl,
-      parameters,
-      headers,
-      errorContext,
-      maxLengthURL,
-      localCache
-    })).then(function (mapInstantiation) {
-      let _exit;
-      function _temp2(_result) {
-        return _exit ? _result : Promise.resolve(requestWithParameters({
-          baseUrl: dataUrl,
-          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';
-      const _temp = function () {
-        if (format === 'tilejson') {
-          return Promise.resolve(requestWithParameters({
-            baseUrl: dataUrl,
-            headers,
-            errorContext,
-            maxLengthURL,
-            localCache
-          })).then(function (json) {
-            if (accessToken) {
-              json.accessToken = accessToken;
-            }
-            _exit = 1;
-            return json;
-          });
-        }
-      }();
-      return _temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp);
+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(_ref4) {
+  let {
+    map,
+    tileIsFullyVisible,
+    geometryIntersection,
+    data,
+    type,
+    bbox,
+    tileFormat,
+    uniqueIdProperty,
+    options
+  } = _ref4;
+  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
     });
-  } catch (e) {
-    return Promise.reject(e);
   }
-};
-const SOURCE_DEFAULTS = {
-  apiBaseUrl: DEFAULT_API_BASE_URL,
-  clientId: getClient(),
-  format: 'tilejson',
-  headers: {},
-  maxLengthURL: DEFAULT_MAX_LENGTH_URL
-};
-
-// deck.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-const boundaryQuerySource = function (options) {
-  try {
-    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 Promise.resolve(baseSource('boundary', options, urlParameters));
-  } catch (e) {
-    return Promise.reject(e);
+}
+function addAllFeaturesInTile(_ref5) {
+  let {
+    map,
+    data,
+    type,
+    bbox,
+    tileFormat,
+    uniqueIdProperty,
+    options
+  } = _ref5;
+  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);
+  // @ts-expect-error Missing or changed types?
+  data.pointIndices = pointIndices;
+}
 
-// deck.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-const boundaryTableSource = function (options) {
-  try {
-    const {
-      filters,
-      tilesetTableName,
-      columns,
-      propertiesTableName
-    } = options;
-    const urlParameters = {
-      tilesetTableName,
-      propertiesTableName
-    };
-    if (columns) {
-      urlParameters.columns = columns.join(',');
-    }
-    if (filters) {
-      urlParameters.filters = filters;
-    }
-    return Promise.resolve(baseSource('boundary', options, urlParameters));
-  } catch (e) {
-    return Promise.reject(e);
+function tileFeaturesSpatialIndex(_ref) {
+  let {
+    tiles,
+    spatialFilter,
+    spatialDataColumn,
+    spatialDataType
+  } = _ref;
+  const map = new Map();
+  const spatialIndex = getSpatialIndex(spatialDataType);
+  const resolution = getResolution(tiles, spatialIndex);
+  const spatialIndexIDName = spatialDataColumn ? spatialDataColumn : spatialIndex;
+  if (!resolution) {
+    return [];
   }
-};
-
-const DEFAULT_TILE_SIZE = 512;
-const 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(_ref => {
-      let [zoom] = _ref;
-      return 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);
+  const cells = getCellsCoverGeometry(spatialFilter, spatialIndex, resolution);
+  if (!cells?.length) {
+    return [];
   }
-  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);
+  // We transform cells to Set to improve the performace
+  const cellsSet = new Set(cells);
+  for (const tile of tiles) {
+    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 undefined;
-}
-const 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]];
-// stolen from https://github.com/visgl/deck.gl/blob/master/modules/carto/src/layers/h3-tileset-2d.ts
-// Relative scale factor (0 = no biasing, 2 = a few hexagons cover view)
-const BIAS = 2;
-/**
- * Resolution conversion function. Takes a WebMercatorViewport and returns
- * a H3 resolution such that the screen space size of the hexagons is
- * "similar" to the given tileSize on screen. Intended for use with deck.gl.
- * @internal
- */
-function _getHexagonResolution(viewport, tileSize) {
-  // Difference in given tile size compared to deck's internal 512px tile size,
-  // expressed as an offset to the viewport zoom.
-  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));
-  // Clip and bias
-  return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
+  return Array.from(map.values());
 }
-
-/**
- * Source for Widget API requests on a data source defined by a SQL query.
- *
- * Abstract class. Use {@link WidgetQuerySource} or {@link WidgetTableSource}.
- */
-class WidgetSource {
-  constructor(props) {
-    this.props = void 0;
-    this.props = {
-      ...WidgetSource.defaultProps,
-      ...props
-    };
+function getResolution(tiles, spatialIndex) {
+  const data = tiles.find(tile => tile.data?.length)?.data;
+  if (!data) {
+    return;
   }
-  _getModelSource(owner) {
-    const props = this.props;
-    return {
-      apiVersion: props.apiVersion,
-      apiBaseUrl: props.apiBaseUrl,
-      clientId: props.clientId,
-      accessToken: props.accessToken,
-      connectionName: props.connectionName,
-      filters: getApplicableFilters(owner, props.filters),
-      filtersLogicalOperator: props.filtersLogicalOperator,
-      spatialDataType: props.spatialDataType,
-      spatialDataColumn: props.spatialDataColumn,
-      dataResolution: props.dataResolution
-    };
+  if (spatialIndex === exports.SpatialIndex.QUADBIN) {
+    return Number(quadbin.getResolution(data[0].id));
   }
-  _getSpatialFiltersResolution(source, spatialFilter, referenceViewState) {
-    // spatialFiltersResolution applies only to spatial index sources.
-    if (!spatialFilter || source.spatialDataType === 'geo') {
-      return;
-    }
-    if (!referenceViewState) {
-      throw new Error('Missing required option, "spatialIndexReferenceViewState".');
-    }
-    return getSpatialFiltersResolution(source, referenceViewState);
+  if (spatialIndex === exports.SpatialIndex.H3) {
+    return h3Js.getResolution(data[0].id);
   }
 }
-WidgetSource.defaultProps = {
-  apiVersion: exports.ApiVersion.V3,
-  apiBaseUrl: DEFAULT_API_BASE_URL,
-  clientId: getClient(),
-  filters: {},
-  filtersLogicalOperator: 'and'
-};
-
-/**
- * Return more descriptive error from API
- * @internalRemarks Source: @carto/react-api
- */
-
-/** @internalRemarks Source: @carto/react-api */
-
-function _catch(body, recover) {
-  try {
-    var result = body();
-  } catch (e) {
-    return recover(e);
+const bboxWest = [-180, -90, 0, 90];
+const bboxEast = [0, -90, 180, 90];
+function getCellsCoverGeometry(geometry, spatialIndex, resolution) {
+  if (spatialIndex === exports.SpatialIndex.QUADBIN) {
+    // @ts-expect-error TODO: Probably ought to be stricter about number vs. bigint types in this file.
+    return quadbin.geometryToCells(geometry, resolution);
   }
-  if (result && result.then) {
-    return result.then(void 0, recover);
+  if (spatialIndex === exports.SpatialIndex.H3) {
+    // The current H3 polyfill algorithm can't deal with polygon segments of greater than 180 degrees longitude
+    // so we clip the geometry to be sure that none of them is greater than 180 degrees
+    // https://github.com/uber/h3-js/issues/24#issuecomment-431893796
+    return h3Js.polygonToCells(bboxClip(geometry, bboxWest).geometry.coordinates, resolution, true).concat(h3Js.polygonToCells(bboxClip(geometry, bboxEast).geometry.coordinates, resolution, true));
   }
-  return result;
 }
-const makeCall = function (_ref2) {
-  let {
-    url,
-    accessToken,
-    opts
-  } = _ref2;
-  try {
-    let _exit;
-    function _temp2(_result) {
-      if (_exit) ;
-      if (!response.ok) {
-        dealWithApiError({
-          response,
-          data
-        });
-      }
-      return data;
-    }
-    let response;
-    let data;
-    const isPost = opts?.method === 'POST';
-    const _temp = _catch(function () {
-      return Promise.resolve(fetch(url.toString(), {
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          ...(isPost && {
-            'Content-Type': 'application/json'
-          })
-        },
-        ...(isPost && {
-          method: opts?.method,
-          body: opts?.body
-        }),
-        signal: opts?.abortController?.signal,
-        ...opts?.otherOptions
-      })).then(function (_fetch) {
-        response = _fetch;
-        return Promise.resolve(response.json()).then(function (_response$json) {
-          data = _response$json;
-        });
-      });
-    }, function (error) {
-      if (error.name === 'AbortError') throw error;
-      throw new Error(`Failed request: ${error}`);
-    });
-    return Promise.resolve(_temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp));
-  } catch (e) {
-    return Promise.reject(e);
-  }
-};
-function dealWithApiError(_ref) {
-  let {
-    response,
-    data
-  } = _ref;
-  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');
+function getSpatialIndex(spatialDataType) {
+  switch (spatialDataType) {
+    case 'h3':
+      return exports.SpatialIndex.H3;
+    case 'quadbin':
+      return exports.SpatialIndex.QUADBIN;
     default:
-      const msg = data && data.error && typeof data.error === 'string' ? data.error : JSON.stringify(data?.hint || data.error?.[0]);
-      throw new Error(msg);
+      throw new Error('Unexpected spatial data type');
   }
 }
 
-/** @internalRemarks Source: @carto/react-api */
-const AVAILABLE_MODELS = ['category', 'histogram', 'formula', 'pick', 'timeseries', 'range', 'scatterplot', 'table'];
-const {
-  V3
-} = exports.ApiVersion;
-const REQUEST_GET_MAX_URL_LENGTH = 2048;
 /**
- * Execute a SQL model request.
- * @internalRemarks Source: @carto/react-api
+ * Current version of @carto/api-client.
+ * @internal
  */
-function executeModel(props) {
-  assert$1(props.source, 'executeModel: missing source');
-  assert$1(props.model, 'executeModel: missing model');
-  assert$1(props.params, 'executeModel: missing params');
-  assert$1(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;
-  assert$1(apiBaseUrl, 'executeModel: missing apiBaseUrl');
-  assert$1(accessToken, 'executeModel: missing accessToken');
-  assert$1(apiVersion === V3, 'executeModel: SQL Model API requires CARTO 3+');
-  assert$1(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;
-  // Picking Model API requires 'spatialDataColumn'.
-  if (model === 'pick') {
-    queryParams.spatialDataColumn = spatialDataColumn;
+/** @internal */
+const V3_MINOR_VERSION = '3.4';
+/** @privateRemarks Source: @carto/constants, @deck.gl/carto */
+const DEFAULT_GEO_COLUMN = 'geom';
+/**
+ * Fastly default limit is 8192; leave some padding.
+ * @privateRemarks Source: @deck.gl/carto
+ */
+const DEFAULT_MAX_LENGTH_URL = 7000;
+/** @privateRemarks Source: @deck.gl/carto */
+const DEFAULT_TILE_RESOLUTION = 0.5;
+/**
+ * @privateRemarks Source: @deck.gl/carto
+ * @internal
+ */
+const DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
+/**
+ * @privateRemarks Source: @deck.gl/carto
+ * @internal
+ */
+const DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
+
+function tileFeaturesRaster(_ref) {
+  let {
+    tiles,
+    ...options
+  } = _ref;
+  // Cache band metadata for faster lookup while iterating over pixels.
+  const bandMetadataByName = {};
+  for (const band of options.rasterMetadata.bands) {
+    bandMetadataByName[band.name] = band;
   }
-  // API supports multiple filters, we apply it only to spatialDataColumn
-  const spatialFilters = source.spatialFilter ? {
-    [spatialDataColumn]: source.spatialFilter
-  } : undefined;
-  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] !== undefined) {
-      params.append(key, String(object[key]));
-    }
-  }
-  return params;
-}
-
-/**
- * Source for Widget API requests.
- *
- * Abstract class. Use {@link WidgetQuerySource} or {@link WidgetTableSource}.
- */
-class WidgetRemoteSource extends WidgetSource {
-  getCategories(options) {
-    try {
-      const _this = this;
-      const {
-        filterOwner,
-        spatialFilter,
-        spatialFiltersMode,
-        spatialIndexReferenceViewState,
-        abortController,
-        ...params
-      } = options;
-      const {
-        column,
-        operation,
-        operationColumn
-      } = params;
-      const source = _this.getModelSource(filterOwner);
-      const spatialFiltersResolution = _this._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
-      return Promise.resolve(executeModel({
-        model: 'category',
-        source: {
-          ...source,
-          spatialFiltersResolution,
-          spatialFiltersMode,
-          spatialFilter
-        },
-        params: {
-          column,
-          operation,
-          operationColumn: operationColumn || column
-        },
-        opts: {
-          abortController
-        }
-      }).then(res => normalizeObjectKeys(res.rows)));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-  getFeatures(options) {
-    try {
-      const _this2 = this;
-      const {
-        filterOwner,
-        spatialFilter,
-        spatialFiltersMode,
-        spatialIndexReferenceViewState,
-        abortController,
-        ...params
-      } = options;
-      const {
-        columns,
-        dataType,
-        featureIds,
-        z,
-        limit,
-        tileResolution
-      } = params;
-      const source = _this2.getModelSource(filterOwner);
-      const spatialFiltersResolution = _this2._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
-      return Promise.resolve(executeModel({
-        model: 'pick',
-        source: {
-          ...source,
-          spatialFiltersResolution,
-          spatialFiltersMode,
-          spatialFilter
-        },
-        params: {
-          columns,
-          dataType,
-          featureIds,
-          z,
-          limit: limit || 1000,
-          tileResolution: tileResolution || DEFAULT_TILE_RESOLUTION
-        },
-        opts: {
-          abortController
-        }
-        // Avoid `normalizeObjectKeys()`, which changes column names.
-      }).then(_ref => {
-        let {
-          rows
-        } = _ref;
-        return {
-          rows
-        };
-      }));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-  getFormula(options) {
-    try {
-      const _this3 = this;
-      const {
-        filterOwner,
-        spatialFilter,
-        spatialFiltersMode,
-        spatialIndexReferenceViewState,
-        abortController,
-        operationExp,
-        ...params
-      } = options;
-      const {
-        column,
-        operation
-      } = params;
-      const source = _this3.getModelSource(filterOwner);
-      const spatialFiltersResolution = _this3._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
-      return Promise.resolve(executeModel({
-        model: 'formula',
-        source: {
-          ...source,
-          spatialFiltersResolution,
-          spatialFiltersMode,
-          spatialFilter
-        },
-        params: {
-          column: column ?? '*',
-          operation: operation ?? 'count',
-          operationExp
-        },
-        opts: {
-          abortController
-        }
-      }).then(res => normalizeObjectKeys(res.rows[0])));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-  getHistogram(options) {
-    try {
-      const _this4 = this;
-      const {
-        filterOwner,
-        spatialFilter,
-        spatialFiltersMode,
-        spatialIndexReferenceViewState,
-        abortController,
-        ...params
-      } = options;
-      const {
-        column,
-        operation,
-        ticks
-      } = params;
-      const source = _this4.getModelSource(filterOwner);
-      const spatialFiltersResolution = _this4._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
-      return Promise.resolve(executeModel({
-        model: 'histogram',
-        source: {
-          ...source,
-          spatialFiltersResolution,
-          spatialFiltersMode,
-          spatialFilter
-        },
-        params: {
-          column,
-          operation,
-          ticks
-        },
-        opts: {
-          abortController
-        }
-      }).then(res => normalizeObjectKeys(res.rows))).then(function (data) {
-        if (data.length) {
-          // Given N ticks the API returns up to N+1 bins, omitting any empty bins. Bins
-          // include 1 bin below the lowest tick, N-1 between ticks, and 1 bin above the highest tick.
-          const result = Array(ticks.length + 1).fill(0);
-          data.forEach(_ref2 => {
-            let {
-              tick,
-              value
-            } = _ref2;
-            return result[tick] = value;
-          });
-          return result;
-        }
-        return [];
-      });
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-  getRange(options) {
-    try {
-      const _this5 = this;
-      const {
-        filterOwner,
-        spatialFilter,
-        spatialFiltersMode,
-        spatialIndexReferenceViewState,
-        abortController,
-        ...params
-      } = options;
-      const {
-        column
-      } = params;
-      const source = _this5.getModelSource(filterOwner);
-      const spatialFiltersResolution = _this5._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
-      return Promise.resolve(executeModel({
-        model: 'range',
-        source: {
-          ...source,
-          spatialFiltersResolution,
-          spatialFiltersMode,
-          spatialFilter
-        },
-        params: {
-          column
-        },
-        opts: {
-          abortController
-        }
-      }).then(res => normalizeObjectKeys(res.rows[0])));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-  getScatter(options) {
-    try {
-      const _this6 = this;
-      const {
-        filterOwner,
-        spatialFilter,
-        spatialFiltersMode,
-        spatialIndexReferenceViewState,
-        abortController,
-        ...params
-      } = options;
-      const {
-        xAxisColumn,
-        xAxisJoinOperation,
-        yAxisColumn,
-        yAxisJoinOperation
-      } = params;
-      const source = _this6.getModelSource(filterOwner);
-      const spatialFiltersResolution = _this6._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
-      // Make sure this is sync with the same constant in cloud-native/maps-api
-      const HARD_LIMIT = 500;
-      return Promise.resolve(executeModel({
-        model: 'scatterplot',
-        source: {
-          ...source,
-          spatialFiltersResolution,
-          spatialFiltersMode,
-          spatialFilter
-        },
-        params: {
-          xAxisColumn,
-          xAxisJoinOperation,
-          yAxisColumn,
-          yAxisJoinOperation,
-          limit: HARD_LIMIT
-        },
-        opts: {
-          abortController
+  // Omit empty and invisible tiles for simpler processing and types.
+  tiles = tiles.filter(isRasterTileVisible);
+  if (tiles.length === 0) return [];
+  // Raster tiles, and all pixels, are quadbin cells. Resolution of a pixel is
+  // the resolution of the tile, plus the number of subdivisions. Block size
+  // must be square, N x N, where N is a power of two.
+  const tileResolution = quadbin.getResolution(tiles[0].index.q);
+  const tileBlockSize = tiles[0].data.blockSize;
+  const cellResolution = tileResolution + BigInt(Math.log2(tileBlockSize));
+  // Compute covering cells for the spatial filter, at same resolution as the
+  // raster pixels, to be used as a mask.
+  const spatialFilterCells = new Set(quadbin.geometryToCells(options.spatialFilter, cellResolution));
+  const data = new Map();
+  for (const tile of tiles) {
+    const parent = tile.index.q;
+    const children = cellToChildrenSorted(parent, cellResolution);
+    // For each pixel/cell within the spatial filter, create a FeatureData.
+    // Order is row-major, starting from NW and ending at SE.
+    for (let i = 0; i < children.length; i++) {
+      if (!spatialFilterCells.has(children[i])) continue;
+      const cellData = {};
+      let cellDataExists = false;
+      for (const band in tile.data.cells.numericProps) {
+        const value = tile.data.cells.numericProps[band].value[i];
+        // TODO(cleanup): nodata should be a number, not a string.
+        if (Number(bandMetadataByName[band].nodata) !== value) {
+          cellData[band] = tile.data.cells.numericProps[band].value[i];
+          cellDataExists = true;
         }
-      }).then(res => normalizeObjectKeys(res.rows)).then(res => res.map(_ref3 => {
-        let {
-          x,
-          y
-        } = _ref3;
-        return [x, y];
-      })));
-    } catch (e) {
-      return Promise.reject(e);
+      }
+      if (cellDataExists) {
+        data.set(children[i], cellData);
+      }
     }
   }
-  getTable(options) {
-    try {
-      const _this7 = this;
-      const {
-        filterOwner,
-        spatialFilter,
-        spatialFiltersMode,
-        spatialIndexReferenceViewState,
-        abortController,
-        ...params
-      } = options;
-      const {
-        columns,
-        sortBy,
-        sortDirection,
-        offset = 0,
-        limit = 10
-      } = params;
-      const source = _this7.getModelSource(filterOwner);
-      const spatialFiltersResolution = _this7._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
-      return Promise.resolve(executeModel({
-        model: 'table',
-        source: {
-          ...source,
-          spatialFiltersResolution,
-          spatialFiltersMode,
-          spatialFilter
-        },
-        params: {
-          column: columns,
-          sortBy,
-          sortDirection,
-          limit,
-          offset
-        },
-        opts: {
-          abortController
-        }
-      }).then(res => ({
-        // Avoid `normalizeObjectKeys()`, which changes column names.
-        rows: res.rows ?? res.ROWS,
-        totalCount: res.metadata?.total ?? res.METADATA?.TOTAL
-      })));
-    } catch (e) {
-      return Promise.reject(e);
+  return Array.from(data.values());
+}
+/**
+ * Detects whether a given {@link Tile} is a {@link RasterTile}.
+ * @privateRemarks Method of detection is arbitrary, and may be changed.
+ */
+function isRasterTile(tile) {
+  return !!tile.data?.cells;
+}
+function isRasterTileVisible(tile) {
+  return !!(tile.isVisible && tile.data?.cells?.numericProps);
+}
+/**
+ * For the raster format, children are sorted in row-major order, starting from
+ * NW and ending at SE. Order returned by quadbin's cellToChildren() is not
+ * defined (and not related to the raster format), so sort explicitly here.
+ */
+function cellToChildrenSorted(parent, resolution) {
+  return quadbin.cellToChildren(parent, resolution).sort((cellA, cellB) => {
+    const tileA = quadbin.cellToTile(cellA);
+    const tileB = quadbin.cellToTile(cellB);
+    if (tileA.y !== tileB.y) {
+      return tileA.y > tileB.y ? 1 : -1;
     }
-  }
-  getTimeSeries(options) {
-    try {
-      const _this8 = this;
-      const {
-        filterOwner,
-        abortController,
-        spatialFilter,
-        spatialFiltersMode,
-        spatialIndexReferenceViewState,
-        ...params
-      } = options;
-      const {
-        column,
-        operationColumn,
-        joinOperation,
-        operation,
-        stepSize,
-        stepMultiplier,
-        splitByCategory,
-        splitByCategoryLimit,
-        splitByCategoryValues
-      } = params;
-      const source = _this8.getModelSource(filterOwner);
-      const spatialFiltersResolution = _this8._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
-      return Promise.resolve(executeModel({
-        model: 'timeseries',
-        source: {
-          ...source,
-          spatialFiltersResolution,
-          spatialFiltersMode,
-          spatialFilter
-        },
-        params: {
-          column,
-          stepSize,
-          stepMultiplier,
-          operationColumn: operationColumn || column,
-          joinOperation,
-          operation,
-          splitByCategory,
-          splitByCategoryLimit,
-          splitByCategoryValues
-        },
-        opts: {
-          abortController
-        }
-      }).then(res => ({
-        rows: normalizeObjectKeys(res.rows),
-        categories: res.metadata?.categories
-      })));
-    } catch (e) {
-      return Promise.reject(e);
+    return tileA.x > tileB.x ? 1 : -1;
+  });
+}
+
+const FILTER_TYPES = new Set(Object.values(exports.FilterType));
+const isFilterType = type => FILTER_TYPES.has(type);
+/**
+ * @privateRemarks Source: @carto/react-widgets
+ * @internal
+ */
+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][type] = filter;
+      }
     }
   }
+  return applicableFilters;
 }
-
 /**
- * Source for Widget API requests on a data source defined by a SQL query.
- *
- * Generally not intended to be constructed directly. Instead, call
- * {@link vectorQuerySource}, {@link h3QuerySource}, or {@link quadbinQuerySource},
- * which can be shared with map layers. Sources contain a `widgetSource` property,
- * for use by widget implementations.
- *
- * Example:
- *
- * ```javascript
- * import { vectorQuerySource } from '@carto/api-client';
- *
- * const data = vectorQuerySource({
- *   accessToken: '••••',
- *   connectionName: 'carto_dw',
- *   sqlQuery: 'SELECT * FROM carto-demo-data.demo_tables.retail_stores'
- * });
+ * Due to each data warehouse having its own behavior with columns,
+ * we need to normalize them and transform every key to lowercase.
  *
- * const { widgetSource } = await data;
- * ```
+ * @privateRemarks Source: @carto/react-widgets
+ * @internal
  */
-class WidgetQuerySource extends WidgetRemoteSource {
-  getModelSource(owner) {
-    return {
-      ...super._getModelSource(owner),
-      type: 'query',
-      data: this.props.sqlQuery,
-      queryParameters: this.props.queryParameters
-    };
+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, _ref) => {
+    let [key, value] = _ref;
+    acc[key.toLowerCase()] = typeof value === 'object' && value ? normalizeObjectKeys(value) : value;
+    return acc;
+  }, {});
+}
+/** @privateRemarks Source: @carto/react-core */
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+/**
+ * @privateRemarks Source: @carto/react-core
+ * @internal
+ */
+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);
+  }
+}
+InvalidColumnError.NAME = 'InvalidColumnError';
+function isEmptyObject(object) {
+  for (const _ in object) {
+    return false;
+  }
+  return true;
+}
+/** @internal */
+const isObject = x => x !== null && typeof x === 'object';
+/** @internal */
+const isPureObject = x => isObject(x) && x.constructor === {}.constructor;
+
+/** @privateRemarks Source: @carto/react-core */
+function tileFeatures(_ref) {
+  let {
+    tiles,
+    spatialFilter,
+    uniqueIdProperty,
+    tileFormat,
+    spatialDataColumn = DEFAULT_GEO_COLUMN,
+    spatialDataType,
+    rasterMetadata,
+    options = {}
+  } = _ref;
+  if (spatialDataType === 'geo') {
+    return tileFeaturesGeometries({
+      tiles,
+      tileFormat,
+      spatialFilter,
+      uniqueIdProperty,
+      options
+    });
+  }
+  if (tiles.some(isRasterTile)) {
+    assert(rasterMetadata, 'Missing raster metadata');
+    return tileFeaturesRaster({
+      tiles: tiles,
+      spatialFilter,
+      spatialDataColumn,
+      spatialDataType,
+      rasterMetadata
+    });
   }
-}
-
-function makeIntervalComplete(intervals) {
-  return intervals.map(val => {
-    if (val[0] === undefined || val[0] === null) {
-      return [Number.MIN_SAFE_INTEGER, val[1]];
-    }
-    if (val[1] === undefined || val[1] === null) {
-      return [val[0], Number.MAX_SAFE_INTEGER];
-    }
-    return val;
+  return tileFeaturesSpatialIndex({
+    tiles: tiles,
+    spatialFilter,
+    spatialDataColumn,
+    spatialDataType
   });
 }
 
-const filterFunctions = {
-  [exports.FilterType.IN]: filterIn,
-  [exports.FilterType.BETWEEN]: filterBetween,
-  [exports.FilterType.TIME]: filterTime,
-  [exports.FilterType.CLOSED_OPEN]: filterClosedOpen,
-  [exports.FilterType.STRING_SEARCH]: filterStringSearch
-};
-function filterIn(filterValues, featureValue) {
-  return filterValues.includes(featureValue);
-}
-// FilterTypes.BETWEEN
-function filterBetween(filterValues, featureValue) {
-  const checkRange = range => {
-    const [lowerBound, upperBound] = range;
-    return featureValue >= lowerBound && featureValue <= upperBound;
+/**
+ * Creates props for DataFilterExtension, from `@deck.gl/extensions`, given
+ * a set of filters.
+ *
+ * @privateRemarks DataFilterExtension accepts up to 4 values to filter. This
+ *  implementation uses the 1st for all filters except the time filter, and the
+ *  2nd for the time filter.
+ */
+function getDataFilterExtensionProps(filters, filtersLogicalOperator, 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)
   };
-  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.`);
+/** @internal */
+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 === exports.FilterType.TIME) {
+        timeColumn = column;
+        timeFilter = typeData;
+      } else {
+        filtersWithoutTimeType[column] = {
+          [type]: typeData
+        };
+      }
+    }
   }
-}
-// FilterTypes.CLOSED_OPEN
-function filterClosedOpen(filterValues, featureValue) {
-  const checkRange = range => {
-    const [lowerBound, upperBound] = range;
-    return featureValue >= lowerBound && featureValue < upperBound;
+  return {
+    filtersWithoutTimeType,
+    timeColumn,
+    timeFilter
   };
-  return makeIntervalComplete(filterValues).some(checkRange);
 }
-// FilterTypes.STRING_SEARCH
-function filterStringSearch(filterValues, featureValue, params) {
-  if (params === void 0) {
-    params = {};
+/** @internal */
+function getFilterRange(timeFilter, filterSize) {
+  const result = Array(filterSize).fill([0, 0]);
+  // According to getFilterValue all filters are resolved as 0 or 1 in the first position of the array
+  // except the time filter value that is resolved with the real value of the feature in the second position of the array
+  result[0] = [1, 1];
+  if (timeFilter) {
+    const offsetBy = timeFilter.params?.offsetBy || 0;
+    result[1] = timeFilter.values[0].map(v => v - offsetBy);
   }
-  const normalizedFeatureValue = normalize(featureValue, params);
-  const stringRegExp = params.useRegExp ? filterValues : filterValues.map(filterValue => {
-    let stringRegExp = escapeRegExp(normalize(filterValue, params));
-    if (params.mustStart) stringRegExp = `^${stringRegExp}`;
-    if (params.mustEnd) stringRegExp = `${stringRegExp}$`;
-    return stringRegExp;
-  });
-  const regex = new RegExp(stringRegExp.join('|'), params.caseSensitive ? 'g' : 'gi');
-  return !!normalizedFeatureValue.match(regex);
-}
-// Aux
-const specialCharRegExp = /[.*+?^${}()|[\]\\]/g;
-const 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;
-}
-
-const LOGICAL_OPERATOR_METHODS = {
-  and: 'every',
-  or: 'some'
-};
-function passesFilter(columns, filters, feature, filtersLogicalOperator) {
-  const method = LOGICAL_OPERATOR_METHODS[filtersLogicalOperator];
-  return columns[method](column => {
-    const columnFilters = filters[column];
-    const columnFilterTypes = Object.keys(columnFilters);
-    if (!feature || feature[column] === null || feature[column] === undefined) {
-      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, feature[column], columnFilters[filter].params);
-    });
-  });
+  return result;
 }
-function buildFeatureFilter(_ref) {
-  let {
-    filters = {},
-    type = 'boolean',
-    filtersLogicalOperator = 'and'
-  } = _ref;
-  const columns = Object.keys(filters);
-  if (!columns.length) {
-    return () => type === 'number' ? 1 : true;
+/** @internal */
+function getUpdateTriggers(filtersWithoutTimeType, timeColumn, timeFilter) {
+  const result = {
+    ...filtersWithoutTimeType
+  };
+  // We don't want to change the layer UpdateTriggers every time that the time filter changes
+  // because this filter is changed by the time series widget during its animation
+  // so we remove the time filter value from the `updateTriggers`
+  if (timeColumn && timeFilter) {
+    result[timeColumn] = {
+      ...result[timeColumn],
+      offsetBy: timeFilter.params?.offsetBy,
+      [exports.FilterType.TIME]: {} // Allows working with other filters, without an impact on performance.
+    };
   }
-  return feature => {
-    const f = feature.properties || feature;
-    const featurePassesFilter = passesFilter(columns, filters, f, filtersLogicalOperator);
-    return type === 'number' ? Number(featurePassesFilter) : featurePassesFilter;
+  return {
+    getFilterValue: JSON.stringify(result)
   };
 }
-// Apply certain filters to a collection of features
-function applyFilters(features, filters, filtersLogicalOperator) {
-  return Object.keys(filters).length ? features.filter(buildFeatureFilter({
-    filters,
+/** @internal */
+function getFilterValue(filtersWithoutTimeType, timeColumn, timeFilter, filterSize, filtersLogicalOperator) {
+  const result = Array(filterSize).fill(0);
+  const featureFilter = _buildFeatureFilter({
+    filters: filtersWithoutTimeType,
+    type: 'number',
     filtersLogicalOperator
-  })) : features;
-}
-// Binary
-function buildBinaryFeatureFilter(_ref2) {
-  let {
-    filters = {}
-  } = _ref2;
-  const columns = Object.keys(filters);
-  if (!columns.length) {
-    return () => 1;
-  }
-  return (featureIdIdx, binaryData) => passesFilterUsingBinary(columns, filters, featureIdIdx, binaryData);
-}
-function getValueFromNumericProps(featureIdIdx, binaryData, _ref3) {
-  let {
-    column
-  } = _ref3;
-  return binaryData.numericProps?.[column]?.value[featureIdIdx];
-}
-function getValueFromProperties(featureIdIdx, binaryData, _ref4) {
-  let {
-    column
-  } = _ref4;
-  const propertyIdx = binaryData.featureIds.value[featureIdIdx];
-  return binaryData.properties[propertyIdx]?.[column];
-}
-const 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(_ref5 => {
-      let [type, {
-        values
-      }] = _ref5;
-      const filterFn = filterFunctions[type];
-      if (!filterFn) {
-        throw new Error(`"${type}" filter is not implemented.`);
-      }
-      if (!values) return 0;
-      const featureValue = getFeatureValue(featureIdIdx, binaryData, {
-        type: type,
-        column,
-        values
-      });
-      if (featureValue === undefined || featureValue === null) return 0;
-      return filterFn(values, featureValue);
-    });
   });
+  // We evaluate all filters except the time filter using _buildFeatureFilter function.
+  // For the time filter, we return the value of the feature and we will change the getFilterRange result
+  // every time this filter changes
+  return feature => {
+    result[0] = featureFilter(feature);
+    if (timeColumn && timeFilter) {
+      const offsetBy = timeFilter.params?.offsetBy || 0;
+      const f = feature.properties || feature;
+      result[1] = f[timeColumn] - offsetBy;
+    }
+    return result;
+  };
 }
 
-function geojsonFeatures(_ref) {
+/**
+ * Adds a {@link Filter} to the filter set. Any previous filters with the same
+ * `column` and `type` will be replaced.
+ */
+function addFilter(filters, _ref) {
   let {
-    geojson,
-    spatialFilter,
-    uniqueIdProperty
+    column,
+    type,
+    values,
+    owner
   } = _ref;
-  let uniqueIdx = 0;
-  const map = new Map();
-  if (!spatialFilter) {
-    return [];
-  }
-  for (const feature of geojson.features) {
-    const uniqueId = uniqueIdProperty ? feature.properties[uniqueIdProperty] : ++uniqueIdx;
-    if (!map.has(uniqueId) && intersects(spatialFilter, feature)) {
-      map.set(uniqueId, feature.properties);
-    }
+  if (!filters[column]) {
+    filters[column] = {};
   }
-  return Array.from(map.values());
+  const filter = {
+    values,
+    owner
+  };
+  filters[column][type] = filter;
+  return filters;
 }
-
-// math.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-const DEFAULT_CONFIG = {
-  EPSILON: 1e-12,
-  debug: false,
-  precision: 4,
-  printTypes: false,
-  printDegrees: false,
-  printRowMajor: true,
-  _cartographicRadians: false
-};
-// Configuration is truly global as of v3.6 to ensure single config even if multiple copies of math.gl
-// Multiple copies of config can be quite tricky to debug...
-globalThis.mathgl = globalThis.mathgl || {
-  config: {
-    ...DEFAULT_CONFIG
+/**
+ * Removes one or more {@link Filter filters} from the filter set. If only
+ * `column` is specified, then all filters on that column are removed. If both
+ * `column` and `owner` are specified, then only filters for that column
+ * associated with the owner are removed.
+ */
+function removeFilter(filters, _ref2) {
+  let {
+    column,
+    owner
+  } = _ref2;
+  const filter = filters[column];
+  if (!filter) {
+    return filters;
   }
-};
+  if (owner) {
+    for (const type of Object.values(exports.FilterType)) {
+      if (owner === filter[type]?.owner) {
+        delete filter[type];
+      }
+    }
+  }
+  if (!owner || isEmptyObject(filter)) {
+    delete filters[column];
+  }
+  return filters;
+}
 /**
- * Check if value is an "array"
- * Returns `true` if value is either an array or a typed array
- * Note: returns `false` for `ArrayBuffer` and `DataView` instances
- * @note isTypedArray and isNumericArray are often more useful in TypeScript
+ * Clears all {@link Filter filters} from the filter set.
  */
-function isArray(value) {
-  return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+function clearFilters(filters) {
+  for (const column of Object.keys(filters)) {
+    delete filters[column];
+  }
+  return filters;
 }
-function lerp(a, b, t) {
-  if (isArray(a)) {
-    return a.map((ai, i) => lerp(ai, b[i], t));
+function hasFilter(filters, _ref3) {
+  let {
+    column,
+    owner
+  } = _ref3;
+  const filter = filters[column];
+  if (!filter) {
+    return false;
   }
-  return t * b + (1 - t) * a;
+  if (!owner) {
+    return true;
+  }
+  for (const type of Object.values(exports.FilterType)) {
+    if (owner === filter[type]?.owner) {
+      return true;
+    }
+  }
+  return false;
 }
-
-// Replacement for the external assert method to reduce bundle size
-// Note: We don't use the second "message" argument in calling code,
-// so no need to support it here
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message || '@math.gl/web-mercator: assertion failed.');
+function getFilter(filters, _ref4) {
+  let {
+    column,
+    type,
+    owner
+  } = _ref4;
+  const filter = filters[column];
+  if (!filter) {
+    return null;
   }
+  if (!owner || owner === filter[type]?.owner) {
+    return filter[type] || null;
+  }
+  return null;
 }
 
-// TODO - THE UTILITIES IN THIS FILE SHOULD BE IMPORTED FROM WEB-MERCATOR-VIEWPORT MODULE
-// CONSTANTS
-const PI = Math.PI;
-const PI_4 = PI / 4;
-const DEGREES_TO_RADIANS = PI / 180;
-const RADIANS_TO_DEGREES = 180 / PI;
-const TILE_SIZE = 512;
 /**
- * Project [lng,lat] on sphere onto [x,y] on 512*512 Mercator Zoom 0 tile.
- * Performs the nonlinear part of the web mercator projection.
- * Remaining projection is done with 4x4 matrices which also handles
- * perspective.
+ * Returns a {@link SpatialFilter} for a given viewport, typically obtained
+ * from deck.gl's `viewport.getBounds()` method ([west, south, east, north]).
+ * If the viewport covers the entire world (to some margin of error in Web
+ * Mercator space), `undefined` is returned instead.
  *
- * @param lngLat - [lng, lat] coordinates
- *   Specifies a point on the sphere to project onto the map.
- * @return [x,y] coordinates.
+ * If the viewport extends beyond longitude range [-180, +180], the polygon
+ * may be reformatted for compatibility with CARTO APIs.
  */
-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_RADIANS;
-  const phi2 = lat * DEGREES_TO_RADIANS;
-  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 createViewportSpatialFilter(viewport) {
+  if (_isGlobalViewport(viewport)) {
+    return;
+  }
+  return createPolygonSpatialFilter(bboxPolygon(viewport).geometry);
 }
 /**
- * Unproject world point [x,y] on map onto {lat, lon} on sphere
+ * Returns a {@link SpatialFilter} for a given {@link Polygon} or
+ * {@link MultiPolygon}. If the polygon(s) extend outside longitude
+ * range [-180, +180], the result may be reformatted for compatibility
+ * with CARTO APIs.
+ */
+function createPolygonSpatialFilter(spatialFilter) {
+  return spatialFilter && _normalizeGeometry(spatialFilter) || undefined;
+}
+/**
+ * Check if a viewport is large enough to represent a global coverage.
+ * In this case the spatial filter parameter for widget calculation is removed.
  *
- * @param xy - array with [x,y] members
- *  representing point on projected map plane
- * @return - array with [x,y] of point on sphere.
- *   Has toArray method if you need a GeoJSON Array.
- *   Per cartographic tradition, lat and lon are specified as degrees.
+ * @privateRemarks Source: @carto/react-core
  */
-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_DEGREES, phi2 * RADIANS_TO_DEGREES];
+function _isGlobalViewport(viewport) {
+  const [minx, miny, maxx, maxy] = viewport;
+  return maxx - minx > 179.5 * 2 && maxy - miny > 85.05 * 2;
 }
-
-const TRANSFORM_FN$1 = {
-  Point: transformPoint$1,
-  MultiPoint: transformMultiPoint$1,
-  LineString: transformLineString$1,
-  MultiLineString: transformMultiLineString$1,
-  Polygon: transformPolygon$1,
-  MultiPolygon: transformMultiPolygon$1
-};
 /**
- * Transform WGS84 coordinates to tile coords.
- * It's the inverse of deck.gl coordinate-transform (https://github.com/visgl/deck.gl/blob/master/modules/geo-layers/src/mvt-layer/coordinate-transform.js)
+ * Normalized a geometry, coming from a mask or a viewport. The parts
+ * spanning outside longitude range [-180, +180] are clipped and "folded"
+ * back to the valid range and unioned to the polygons inide that range.
  *
- * @param geometry - any valid geojson geometry
- * @param bbox - geojson bbox
+ * It results in a Polygon or MultiPolygon strictly inside the validity range.
+ *
+ * @privateRemarks Source: @carto/react-core
  */
-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');
+function _normalizeGeometry(geometry) {
+  const WORLD = [-180, -90, +180, +90];
+  const worldClip = _clean(bboxClip(geometry, WORLD).geometry);
+  const geometryTxWest = _tx(geometry, 360);
+  const geometryTxEast = _tx(geometry, -360);
+  let result = worldClip;
+  if (result && geometryTxWest) {
+    const worldWestClip = _clean(bboxClip(geometryTxWest, WORLD).geometry);
+    if (worldWestClip) {
+      const collection = helpers.featureCollection([helpers.feature(result), helpers.feature(worldWestClip)]);
+      const merged = union(collection);
+      result = merged ? _clean(merged.geometry) : result;
+    }
   }
-  const transformFn = TRANSFORM_FN$1[geometry.type];
-  const coordinates = transformFn(geometry.coordinates, projectedBbox);
-  return {
-    ...geometry,
-    coordinates
-  };
+  if (result && geometryTxEast) {
+    const worldEastClip = _clean(bboxClip(geometryTxEast, WORLD).geometry);
+    if (worldEastClip) {
+      const collection = helpers.featureCollection([helpers.feature(result), helpers.feature(worldEastClip)]);
+      const merged = union(collection);
+      result = merged ? _clean(merged.geometry) : result;
+    }
+  }
+  return result;
 }
-function transformPoint$1(_ref, _ref2) {
-  let [pointX, pointY] = _ref;
-  let [nw, se] = _ref2;
-  const x = inverseLerp(nw[0], se[0], pointX);
-  const y = inverseLerp(nw[1], se[1], pointY);
-  return [x, y];
+/** @privateRemarks Source: @carto/react-core */
+function _cleanPolygonCoords(cc) {
+  const coords = cc.filter(c => c.length > 0);
+  return coords.length > 0 ? coords : null;
 }
-function getPoints$1(geometry, bbox) {
-  return geometry.map(g => transformPoint$1(projectFlat(g), bbox));
+/** @privateRemarks Source: @carto/react-core */
+function _cleanMultiPolygonCoords(ccc) {
+  const coords = ccc.map(_cleanPolygonCoords).filter(cc => cc);
+  return coords.length > 0 ? coords : null;
 }
-function transformMultiPoint$1(multiPoint, bbox) {
-  return getPoints$1(multiPoint, bbox);
+/** @privateRemarks Source: @carto/react-core */
+function _clean(geometry) {
+  if (!geometry) {
+    return null;
+  }
+  if (_isPolygon(geometry)) {
+    const coords = _cleanPolygonCoords(geometry.coordinates);
+    return coords ? helpers.polygon(coords).geometry : null;
+  }
+  if (_isMultiPolygon(geometry)) {
+    const coords = _cleanMultiPolygonCoords(geometry.coordinates);
+    return coords ? helpers.multiPolygon(coords).geometry : null;
+  }
+  return null;
 }
-function transformLineString$1(line, bbox) {
-  return getPoints$1(line, bbox);
+/** @privateRemarks Source: @carto/react-core */
+function _txContourCoords(cc, distance) {
+  return cc.map(c => [c[0] + distance, c[1]]);
 }
-function transformMultiLineString$1(multiLineString, bbox) {
-  return multiLineString.map(lineString => transformLineString$1(lineString, bbox));
+/** @privateRemarks Source: @carto/react-core */
+function _txPolygonCoords(ccc, distance) {
+  return ccc.map(cc => _txContourCoords(cc, distance));
 }
-function transformPolygon$1(polygon, bbox) {
-  return polygon.map(polygonRing => getPoints$1(polygonRing, bbox));
+/** @privateRemarks Source: @carto/react-core */
+function _txMultiPolygonCoords(cccc, distance) {
+  return cccc.map(ccc => _txPolygonCoords(ccc, distance));
+}
+/** @privateRemarks Source: @carto/react-core */
+function _tx(geometry, distance) {
+  if (geometry && invariant.getType(geometry) === 'Polygon') {
+    const coords = _txPolygonCoords(geometry.coordinates, distance);
+    return helpers.polygon(coords).geometry;
+  } else if (geometry && invariant.getType(geometry) === 'MultiPolygon') {
+    const coords = _txMultiPolygonCoords(geometry.coordinates, distance);
+    return helpers.multiPolygon(coords).geometry;
+  } else {
+    return null;
+  }
+}
+function _isPolygon(geometry) {
+  return invariant.getType(geometry) === 'Polygon';
+}
+function _isMultiPolygon(geometry) {
+  return invariant.getType(geometry) === 'MultiPolygon';
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+function joinPath() {
+  return [].slice.call(arguments).map(part => part.endsWith('/') ? part.slice(0, -1) : part).join('/');
+}
+function buildV3Path(apiBaseUrl, version, endpoint) {
+  return joinPath(apiBaseUrl, version, endpoint, ...[].slice.call(arguments, 3));
+}
+/** @internal Required by fetchMap(). */
+function buildPublicMapUrl(_ref) {
+  let {
+    apiBaseUrl,
+    cartoMapId
+  } = _ref;
+  return buildV3Path(apiBaseUrl, 'v3', 'maps', 'public', cartoMapId);
 }
-function transformMultiPolygon$1(multiPolygon, bbox) {
-  return multiPolygon.map(polygon => transformPolygon$1(polygon, bbox));
+/** @internal Required by fetchMap(). */
+function buildStatsUrl(_ref2) {
+  let {
+    attribute,
+    apiBaseUrl,
+    connectionName,
+    source,
+    type
+  } = _ref2;
+  if (type === 'query') {
+    return buildV3Path(apiBaseUrl, 'v3', 'stats', connectionName, attribute);
+  }
+  // type === 'table'
+  return buildV3Path(apiBaseUrl, 'v3', 'stats', connectionName, source, attribute);
 }
-function projectFlat(xyz) {
-  return lngLatToWorld(xyz);
+function buildSourceUrl(_ref3) {
+  let {
+    apiBaseUrl,
+    connectionName,
+    endpoint
+  } = _ref3;
+  return buildV3Path(apiBaseUrl, 'v3', 'maps', connectionName, endpoint);
 }
-function inverseLerp(a, b, x) {
-  return (x - a) / (b - a);
+function buildQueryUrl(_ref4) {
+  let {
+    apiBaseUrl,
+    connectionName
+  } = _ref4;
+  return buildV3Path(apiBaseUrl, 'v3', 'sql', connectionName, 'query');
 }
 
-const TRANSFORM_FN = {
-  Point: transformPoint,
-  MultiPoint: transformMultiPoint,
-  LineString: transformLineString,
-  MultiLineString: transformMultiLineString,
-  Polygon: transformPolygon,
-  MultiPolygon: transformMultiPolygon
-};
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 /**
- * Transform tile coords to WGS84 coordinates.
  *
- * @param geometry - any valid geojson geometry
- * @param bbox - geojson bbox
+ * Custom error for reported errors in CARTO Maps API.
+ * Provides useful debugging information in console and context for applications.
+ *
  */
-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');
+class CartoAPIError 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 += `\n${responseString}`;
+    for (const key of Object.keys(errorContext)) {
+      if (key === 'requestType') continue;
+      message += `\n${formatErrorKey(key)}: ${errorContext[key]}`;
+    }
+    message += '\n';
+    super(message);
+    /** Source error from server */
+    this.error = void 0;
+    /** Context (API call & parameters) in which error occured */
+    this.errorContext = void 0;
+    /** Response from server */
+    this.response = void 0;
+    /** JSON Response from server */
+    this.responseJson = void 0;
+    this.name = 'CartoAPIError';
+    this.response = response;
+    this.responseJson = responseJson;
+    this.error = error;
+    this.errorContext = errorContext;
   }
-  const transformFn = TRANSFORM_FN[geometry.type];
-  const coordinates = transformFn(geometry.coordinates, projectedBbox);
-  return {
-    ...geometry,
-    coordinates
-  };
-}
-function transformPoint(_ref, _ref2) {
-  let [pointX, pointY] = _ref;
-  let [nw, se] = _ref2;
-  const x = lerp(nw[0], se[0], pointX);
-  const y = lerp(nw[1], se[1], pointY);
-  return worldToLngLat([x, y]);
-}
-function getPoints(geometry, bbox) {
-  return geometry.map(g => transformPoint(g, bbox));
 }
-function transformMultiPoint(multiPoint, bbox) {
-  return getPoints(multiPoint, bbox);
+/**
+ * Converts camelCase to Camel Case
+ */
+function formatErrorKey(key) {
+  return key.replace(/([A-Z])/g, ' $1').replace(/^./, s => s.toUpperCase());
 }
-function transformLineString(line, bbox) {
-  return getPoints(line, bbox);
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const requestWithParameters = function (_ref) {
+  let {
+    baseUrl,
+    parameters = {},
+    headers: customHeaders = {},
+    errorContext,
+    maxLengthURL = DEFAULT_MAX_LENGTH_URL,
+    localCache
+  } = _ref;
+  try {
+    // Parameters added to all requests issued with `requestWithParameters()`.
+    // These parameters override parameters already in the base URL, but not
+    // user-provided parameters.
+    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 Promise.resolve(REQUEST_CACHE.get(key));
+    }
+    const url = createURLWithParameters(baseUrl, parameters);
+    const headers = {
+      ...DEFAULT_HEADERS,
+      ...customHeaders
+    };
+    /* global fetch */
+    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 Promise.resolve(jsonPromise);
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+const DEFAULT_HEADERS = {
+  Accept: 'application/json',
+  'Content-Type': 'application/json'
+};
+const DEFAULT_REQUEST_CACHE = new Map();
+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 transformMultiLineString(multiLineString, bbox) {
-  return multiLineString.map(lineString => transformLineString(lineString, bbox));
+function createCacheKey(baseUrl, parameters, headers) {
+  const parameterEntries = Object.entries(parameters).sort((_ref2, _ref3) => {
+    let [a] = _ref2;
+    let [b] = _ref3;
+    return a > b ? 1 : -1;
+  });
+  const headerEntries = Object.entries(headers).sort((_ref4, _ref5) => {
+    let [a] = _ref4;
+    let [b] = _ref5;
+    return a > b ? 1 : -1;
+  });
+  return JSON.stringify({
+    baseUrl,
+    parameters: parameterEntries,
+    headers: headerEntries
+  });
 }
-function transformPolygon(polygon, bbox) {
-  return polygon.map(polygonRing => getPoints(polygonRing, bbox));
+/**
+ * Appends query string parameters to a URL. Existing URL parameters are kept,
+ * unless there is a conflict, in which case the new parameters override
+ * those already in the URL.
+ */
+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 transformMultiPolygon(multiPolygon, bbox) {
-  return multiPolygon.map(polygon => transformPolygon(polygon, bbox));
+/**
+ * Deletes query string parameters from a URL.
+ */
+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();
 }
 
-const FEATURE_GEOM_PROPERTY = '__geomValue';
-function tileFeaturesGeometries(_ref) {
-  let {
-    tiles,
-    tileFormat,
-    spatialFilter,
-    uniqueIdProperty,
-    options
-  } = _ref;
-  const map = new Map();
-  for (const tile of tiles) {
-    // Discard if it's not a visible tile (only check false value, not undefined)
-    // or tile has not data
-    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);
-    // Clip the geometry to intersect with the tile
-    const spatialFilterFeature = {
-      type: 'Feature',
-      geometry: spatialFilter,
-      properties: {}
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const baseSource = function (endpoint, options, urlParameters) {
+  try {
+    const {
+      accessToken,
+      connectionName,
+      cache,
+      ...optionalOptions
+    } = options;
+    const mergedOptions = {
+      ...SOURCE_DEFAULTS,
+      accessToken,
+      connectionName,
+      endpoint
     };
-    const clippedGeometryToIntersect = intersect(helpers.featureCollection([bboxToGeom, spatialFilterFeature]));
-    if (!clippedGeometryToIntersect) {
-      continue;
+    for (const key in optionalOptions) {
+      if (optionalOptions[key]) {
+        mergedOptions[key] = optionalOptions[key];
+      }
     }
-    // We assume that MVT tileFormat uses local coordinates so we transform the geometry to intersect to tile coordinates [0..1],
-    // while in the case of 'geojson' or binary, the geometries are already in WGS84
-    const transformedGeometryToIntersect = tileFormat === exports.TileFormat.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
+    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, undefined, 2)
+    };
+    return Promise.resolve(requestWithParameters({
+      baseUrl,
+      parameters,
+      headers,
+      errorContext,
+      maxLengthURL,
+      localCache
+    })).then(function (mapInstantiation) {
+      let _exit;
+      function _temp2(_result) {
+        return _exit ? _result : Promise.resolve(requestWithParameters({
+          baseUrl: dataUrl,
+          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';
+      const _temp = function () {
+        if (format === 'tilejson') {
+          return Promise.resolve(requestWithParameters({
+            baseUrl: dataUrl,
+            headers,
+            errorContext,
+            maxLengthURL,
+            localCache
+          })).then(function (json) {
+            if (accessToken) {
+              json.accessToken = accessToken;
+            }
+            _exit = 1;
+            return json;
+          });
+        }
+      }();
+      return _temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp);
     });
+  } catch (e) {
+    return Promise.reject(e);
   }
-  return Array.from(map.values());
-}
-function processTileFeatureProperties(_ref2) {
-  let {
-    map,
-    data,
-    startIndex,
-    endIndex,
-    type,
-    bbox,
-    tileFormat,
-    uniqueIdProperty,
-    storeGeometry,
-    geometryIntersection
-  } = _ref2;
-  const tileProps = getPropertiesFromTile(data, startIndex);
-  const uniquePropertyValue = getUniquePropertyValue(tileProps, uniqueIdProperty, map);
-  if (!uniquePropertyValue || map.has(uniquePropertyValue)) {
-    return;
+};
+const SOURCE_DEFAULTS = {
+  apiBaseUrl: DEFAULT_API_BASE_URL,
+  clientId: getClient(),
+  format: 'tilejson',
+  headers: {},
+  maxLengthURL: DEFAULT_MAX_LENGTH_URL
+};
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const boundaryQuerySource = function (options) {
+  try {
+    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 Promise.resolve(baseSource('boundary', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
   }
-  let geometry = null;
-  // Only calculate geometry if necessary
-  if (storeGeometry || geometryIntersection) {
+};
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const boundaryTableSource = function (options) {
+  try {
     const {
-      positions
-    } = data;
-    const ringCoordinates = getRingCoordinatesFor(startIndex, endIndex, positions);
-    geometry = getFeatureByType(ringCoordinates, type);
+      filters,
+      tilesetTableName,
+      columns,
+      propertiesTableName
+    } = options;
+    const urlParameters = {
+      tilesetTableName,
+      propertiesTableName
+    };
+    if (columns) {
+      urlParameters.columns = columns.join(',');
+    }
+    if (filters) {
+      urlParameters.filters = filters;
+    }
+    return Promise.resolve(baseSource('boundary', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
   }
-  // If intersection is required, check before proceeding
-  if (geometry && geometryIntersection && !intersects(geometry, geometryIntersection)) {
-    return;
+};
+
+const DEFAULT_TILE_SIZE = 512;
+const 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(_ref => {
+      let [zoom] = _ref;
+      return 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);
   }
-  const properties = parseProperties(tileProps);
-  // Only save geometry if necessary
-  if (storeGeometry && geometry) {
-    properties[FEATURE_GEOM_PROPERTY] = tileFormat === exports.TileFormat.MVT ? transformTileCoordsToWGS84(geometry, bbox) : geometry;
+  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);
   }
-  map.set(uniquePropertyValue, properties);
+  return undefined;
 }
-function addIntersectedFeaturesInTile(_ref3) {
-  let {
-    map,
-    data,
-    geometryIntersection,
-    type,
-    bbox,
-    tileFormat,
-    uniqueIdProperty,
-    options
-  } = _ref3;
-  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
-    });
-  }
+const 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]];
+// stolen from https://github.com/visgl/deck.gl/blob/master/modules/carto/src/layers/h3-tileset-2d.ts
+// Relative scale factor (0 = no biasing, 2 = a few hexagons cover view)
+const BIAS = 2;
+/**
+ * Resolution conversion function. Takes a WebMercatorViewport and returns
+ * a H3 resolution such that the screen space size of the hexagons is
+ * "similar" to the given tileSize on screen. Intended for use with deck.gl.
+ * @internal
+ */
+function _getHexagonResolution(viewport, tileSize) {
+  // Difference in given tile size compared to deck's internal 512px tile size,
+  // expressed as an offset to the viewport zoom.
+  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));
+  // Clip and bias
+  return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
 }
-function getIndices(data) {
-  let indices;
-  switch (data.type) {
-    case 'Point':
-      // @ts-expect-error Missing or changed types?
-      indices = data.pointIndices;
-      break;
-    case 'LineString':
-      indices = data.pathIndices;
-      break;
-    case 'Polygon':
-      indices = data.primitivePolygonIndices;
-      break;
-    default:
-      throw new Error(`Unexpected type, "${data.type}"`);
+
+/**
+ * Source for Widget API requests on a data source defined by a SQL query.
+ *
+ * Abstract class. Use {@link WidgetQuerySource} or {@link WidgetTableSource}.
+ */
+class WidgetSource {
+  constructor(props) {
+    this.props = void 0;
+    this.props = {
+      ...WidgetSource.defaultProps,
+      ...props
+    };
+  }
+  _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
+    };
+  }
+  _getSpatialFiltersResolution(source, spatialFilter, referenceViewState) {
+    // spatialFiltersResolution applies only to spatial index sources.
+    if (!spatialFilter || source.spatialDataType === 'geo') {
+      return;
+    }
+    if (!referenceViewState) {
+      throw new Error('Missing required option, "spatialIndexReferenceViewState".');
+    }
+    return getSpatialFiltersResolution(source, referenceViewState);
   }
-  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];
+WidgetSource.defaultProps = {
+  apiVersion: exports.ApiVersion.V3,
+  apiBaseUrl: DEFAULT_API_BASE_URL,
+  clientId: getClient(),
+  filters: {},
+  filtersLogicalOperator: 'and'
+};
+
+/**
+ * Return more descriptive error from API
+ * @privateRemarks Source: @carto/react-api
+ */
+
+/** @privateRemarks Source: @carto/react-api */
+
+function _catch(body, recover) {
+  try {
+    var result = body();
+  } catch (e) {
+    return recover(e);
+  }
+  if (result && result.then) {
+    return result.then(void 0, recover);
   }
   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);
+const makeCall = function (_ref2) {
+  let {
+    url,
+    accessToken,
+    opts
+  } = _ref2;
+  try {
+    let _exit;
+    function _temp2(_result) {
+      if (_exit) ;
+      if (!response.ok) {
+        dealWithApiError({
+          response,
+          data
+        });
+      }
+      return data;
+    }
+    let response;
+    let data;
+    const isPost = opts?.method === 'POST';
+    const _temp = _catch(function () {
+      return Promise.resolve(fetch(url.toString(), {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          ...(isPost && {
+            'Content-Type': 'application/json'
+          }),
+          ...opts.headers
+        },
+        ...(isPost && {
+          method: opts?.method,
+          body: opts?.body
+        }),
+        signal: opts?.abortController?.signal,
+        ...opts?.otherOptions
+      })).then(function (_fetch) {
+        response = _fetch;
+        return Promise.resolve(response.json()).then(function (_response$json) {
+          data = _response$json;
+        });
+      });
+    }, function (error) {
+      if (error.name === 'AbortError') throw error;
+      throw new Error(`Failed request: ${error}`);
+    });
+    return Promise.resolve(_temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp));
+  } catch (e) {
+    return Promise.reject(e);
   }
-  if (tileProps.uniqueId) {
-    return tileProps.uniqueId;
+};
+function dealWithApiError(_ref) {
+  let {
+    response,
+    data
+  } = _ref;
+  if (data.error === 'Column not found') {
+    throw new InvalidColumnError(`${data.error} ${data.column_name}`);
   }
-  const artificialId = map.size + 1; // a counter, assumed as a valid new id
-  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');
+  if (typeof data.error === 'string' && data.error?.includes('Missing columns')) {
+    throw new InvalidColumnError(data.error);
   }
-}
-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)));
+  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]));
   }
-  return ringCoordinates;
 }
-function calculateFeatures(_ref4) {
-  let {
-    map,
-    tileIsFullyVisible,
-    geometryIntersection,
+
+/** @privateRemarks Source: @carto/react-api */
+const AVAILABLE_MODELS = ['category', 'histogram', 'formula', 'pick', 'timeseries', 'range', 'scatterplot', 'table'];
+const {
+  V3
+} = exports.ApiVersion;
+const REQUEST_GET_MAX_URL_LENGTH = 2048;
+/**
+ * Execute a SQL model request.
+ * @privateRemarks Source: @carto/react-api
+ */
+function executeModel(props) {
+  assert(props.source, 'executeModel: missing source');
+  assert(props.model, 'executeModel: missing model');
+  assert(props.params, 'executeModel: missing params');
+  assert(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;
+  assert(apiBaseUrl, 'executeModel: missing apiBaseUrl');
+  assert(accessToken, 'executeModel: missing accessToken');
+  assert(apiVersion === V3, 'executeModel: SQL Model API requires CARTO 3+');
+  assert(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,
-    bbox,
-    tileFormat,
-    uniqueIdProperty,
-    options
-  } = _ref4;
-  if (!data?.properties.length) {
-    return;
+    client: clientId,
+    source: data,
+    params,
+    queryParameters: source.queryParameters || '',
+    filters,
+    filtersLogicalOperator
+  };
+  const spatialDataColumn = source.spatialDataColumn || DEFAULT_GEO_COLUMN;
+  // Picking Model API requires 'spatialDataColumn'.
+  if (model === 'pick') {
+    queryParams.spatialDataColumn = spatialDataColumn;
   }
-  if (tileIsFullyVisible) {
-    addAllFeaturesInTile({
-      map,
-      data,
-      type,
-      bbox,
-      tileFormat,
-      uniqueIdProperty,
-      options
-    });
-  } else {
-    addIntersectedFeaturesInTile({
-      map,
-      data,
-      geometryIntersection,
-      type,
-      bbox,
-      tileFormat,
-      uniqueIdProperty,
-      options
-    });
+  // API supports multiple filters, we apply it only to spatialDataColumn
+  const spatialFilters = source.spatialFilter ? {
+    [spatialDataColumn]: source.spatialFilter
+  } : undefined;
+  if (spatialFilters) {
+    queryParams.spatialFilters = spatialFilters;
+    queryParams.spatialDataColumn = spatialDataColumn;
+    queryParams.spatialDataType = spatialDataType;
   }
-}
-function addAllFeaturesInTile(_ref5) {
-  let {
-    map,
-    data,
-    type,
-    bbox,
-    tileFormat,
-    uniqueIdProperty,
-    options
-  } = _ref5;
-  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
-    });
+  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 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);
-  // @ts-expect-error Missing or changed types?
-  data.pointIndices = pointIndices;
+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] !== undefined) {
+      params.append(key, String(object[key]));
+    }
+  }
+  return params;
 }
 
-function tileFeaturesSpatialIndex(_ref) {
-  let {
-    tiles,
-    spatialFilter,
-    spatialDataColumn,
-    spatialDataType
-  } = _ref;
-  const map = new Map();
-  const spatialIndex = getSpatialIndex(spatialDataType);
-  const resolution = getResolution(tiles, spatialIndex);
-  const spatialIndexIDName = spatialDataColumn ? spatialDataColumn : spatialIndex;
-  if (!resolution) {
-    return [];
+/**
+ * Source for Widget API requests.
+ *
+ * Abstract class. Use {@link WidgetQuerySource} or {@link WidgetTableSource}.
+ */
+class WidgetRemoteSource extends WidgetSource {
+  constructor() {
+    super(...arguments);
+    this._headers = {};
   }
-  const cells = getCellsCoverGeometry(spatialFilter, spatialIndex, resolution);
-  if (!cells?.length) {
-    return [];
+  /** Assigns HTTP headers to be included on API requests from this source. */
+  setRequestHeaders(headers) {
+    this._headers = headers;
   }
-  // We transform cells to Set to improve the performace
-  const cellsSet = new Set(cells);
-  for (const tile of tiles) {
-    if (tile.isVisible === false || !tile.data) {
-      continue;
+  getCategories(options) {
+    try {
+      const _this = this;
+      const {
+        filters = _this.props.filters,
+        filterOwner,
+        spatialFilter,
+        spatialFiltersMode,
+        spatialIndexReferenceViewState,
+        abortController,
+        ...params
+      } = options;
+      const {
+        column,
+        operation,
+        operationColumn
+      } = params;
+      const source = _this.getModelSource(filters, filterOwner);
+      const spatialFiltersResolution = _this._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
+      return Promise.resolve(executeModel({
+        model: 'category',
+        source: {
+          ...source,
+          spatialFiltersResolution,
+          spatialFiltersMode,
+          spatialFilter
+        },
+        params: {
+          column,
+          operation,
+          operationColumn: operationColumn || column
+        },
+        opts: {
+          abortController,
+          headers: _this._headers
+        }
+      }).then(res => normalizeObjectKeys(res.rows)));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getFeatures(options) {
+    try {
+      const _this2 = this;
+      const {
+        filters = _this2.props.filters,
+        filterOwner,
+        spatialFilter,
+        spatialFiltersMode,
+        spatialIndexReferenceViewState,
+        abortController,
+        ...params
+      } = options;
+      const {
+        columns,
+        dataType,
+        featureIds,
+        z,
+        limit,
+        tileResolution
+      } = params;
+      const source = _this2.getModelSource(filters, filterOwner);
+      const spatialFiltersResolution = _this2._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
+      return Promise.resolve(executeModel({
+        model: 'pick',
+        source: {
+          ...source,
+          spatialFiltersResolution,
+          spatialFiltersMode,
+          spatialFilter
+        },
+        params: {
+          columns,
+          dataType,
+          featureIds,
+          z,
+          limit: limit || 1000,
+          tileResolution: tileResolution || DEFAULT_TILE_RESOLUTION
+        },
+        opts: {
+          abortController,
+          headers: _this2._headers
+        }
+        // Avoid `normalizeObjectKeys()`, which changes column names.
+      }).then(_ref => {
+        let {
+          rows
+        } = _ref;
+        return {
+          rows
+        };
+      }));
+    } catch (e) {
+      return Promise.reject(e);
     }
-    tile.data.forEach(d => {
-      if (cellsSet.has(d.id)) {
-        map.set(d.id, {
-          ...d.properties,
-          [spatialIndexIDName]: d.id
-        });
-      }
-    });
-  }
-  return Array.from(map.values());
-}
-function getResolution(tiles, spatialIndex) {
-  const data = tiles.find(tile => tile.data?.length)?.data;
-  if (!data) {
-    return;
   }
-  if (spatialIndex === exports.SpatialIndex.QUADBIN) {
-    return Number(quadbin.getResolution(data[0].id));
-  }
-  if (spatialIndex === exports.SpatialIndex.H3) {
-    return h3Js.getResolution(data[0].id);
+  getFormula(options) {
+    try {
+      const _this3 = this;
+      const {
+        filters = _this3.props.filters,
+        filterOwner,
+        spatialFilter,
+        spatialFiltersMode,
+        spatialIndexReferenceViewState,
+        abortController,
+        operationExp,
+        ...params
+      } = options;
+      const {
+        column,
+        operation
+      } = params;
+      const source = _this3.getModelSource(filters, filterOwner);
+      const spatialFiltersResolution = _this3._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
+      return Promise.resolve(executeModel({
+        model: 'formula',
+        source: {
+          ...source,
+          spatialFiltersResolution,
+          spatialFiltersMode,
+          spatialFilter
+        },
+        params: {
+          column: column ?? '*',
+          operation: operation ?? 'count',
+          operationExp
+        },
+        opts: {
+          abortController,
+          headers: _this3._headers
+        }
+      }).then(res => normalizeObjectKeys(res.rows[0])));
+    } catch (e) {
+      return Promise.reject(e);
+    }
   }
-}
-const bboxWest = [-180, -90, 0, 90];
-const bboxEast = [0, -90, 180, 90];
-function getCellsCoverGeometry(geometry, spatialIndex, resolution) {
-  if (spatialIndex === exports.SpatialIndex.QUADBIN) {
-    // @ts-expect-error TODO: Probably ought to be stricter about number vs. bigint types in this file.
-    return quadbin.geometryToCells(geometry, resolution);
+  getHistogram(options) {
+    try {
+      const _this4 = this;
+      const {
+        filters = _this4.props.filters,
+        filterOwner,
+        spatialFilter,
+        spatialFiltersMode,
+        spatialIndexReferenceViewState,
+        abortController,
+        ...params
+      } = options;
+      const {
+        column,
+        operation,
+        ticks
+      } = params;
+      const source = _this4.getModelSource(filters, filterOwner);
+      const spatialFiltersResolution = _this4._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
+      return Promise.resolve(executeModel({
+        model: 'histogram',
+        source: {
+          ...source,
+          spatialFiltersResolution,
+          spatialFiltersMode,
+          spatialFilter
+        },
+        params: {
+          column,
+          operation,
+          ticks
+        },
+        opts: {
+          abortController,
+          headers: _this4._headers
+        }
+      }).then(res => normalizeObjectKeys(res.rows))).then(function (data) {
+        if (data.length) {
+          // Given N ticks the API returns up to N+1 bins, omitting any empty bins. Bins
+          // include 1 bin below the lowest tick, N-1 between ticks, and 1 bin above the highest tick.
+          const result = Array(ticks.length + 1).fill(0);
+          data.forEach(_ref2 => {
+            let {
+              tick,
+              value
+            } = _ref2;
+            return result[tick] = value;
+          });
+          return result;
+        }
+        return [];
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
   }
-  if (spatialIndex === exports.SpatialIndex.H3) {
-    // The current H3 polyfill algorithm can't deal with polygon segments of greater than 180 degrees longitude
-    // so we clip the geometry to be sure that none of them is greater than 180 degrees
-    // https://github.com/uber/h3-js/issues/24#issuecomment-431893796
-    return h3Js.polygonToCells(bboxClip(geometry, bboxWest).geometry.coordinates, resolution, true).concat(h3Js.polygonToCells(bboxClip(geometry, bboxEast).geometry.coordinates, resolution, true));
+  getRange(options) {
+    try {
+      const _this5 = this;
+      const {
+        filters = _this5.props.filters,
+        filterOwner,
+        spatialFilter,
+        spatialFiltersMode,
+        spatialIndexReferenceViewState,
+        abortController,
+        ...params
+      } = options;
+      const {
+        column
+      } = params;
+      const source = _this5.getModelSource(filters, filterOwner);
+      const spatialFiltersResolution = _this5._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
+      return Promise.resolve(executeModel({
+        model: 'range',
+        source: {
+          ...source,
+          spatialFiltersResolution,
+          spatialFiltersMode,
+          spatialFilter
+        },
+        params: {
+          column
+        },
+        opts: {
+          abortController,
+          headers: _this5._headers
+        }
+      }).then(res => normalizeObjectKeys(res.rows[0])));
+    } catch (e) {
+      return Promise.reject(e);
+    }
   }
-}
-function getSpatialIndex(spatialDataType) {
-  switch (spatialDataType) {
-    case 'h3':
-      return exports.SpatialIndex.H3;
-    case 'quadbin':
-      return exports.SpatialIndex.QUADBIN;
-    default:
-      throw new Error('Unexpected spatial data type');
+  getScatter(options) {
+    try {
+      const _this6 = this;
+      const {
+        filters = _this6.props.filters,
+        filterOwner,
+        spatialFilter,
+        spatialFiltersMode,
+        spatialIndexReferenceViewState,
+        abortController,
+        ...params
+      } = options;
+      const {
+        xAxisColumn,
+        xAxisJoinOperation,
+        yAxisColumn,
+        yAxisJoinOperation
+      } = params;
+      const source = _this6.getModelSource(filters, filterOwner);
+      const spatialFiltersResolution = _this6._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
+      // Make sure this is sync with the same constant in cloud-native/maps-api
+      const HARD_LIMIT = 500;
+      return Promise.resolve(executeModel({
+        model: 'scatterplot',
+        source: {
+          ...source,
+          spatialFiltersResolution,
+          spatialFiltersMode,
+          spatialFilter
+        },
+        params: {
+          xAxisColumn,
+          xAxisJoinOperation,
+          yAxisColumn,
+          yAxisJoinOperation,
+          limit: HARD_LIMIT
+        },
+        opts: {
+          abortController,
+          headers: _this6._headers
+        }
+      }).then(res => normalizeObjectKeys(res.rows)).then(res => res.map(_ref3 => {
+        let {
+          x,
+          y
+        } = _ref3;
+        return [x, y];
+      })));
+    } catch (e) {
+      return Promise.reject(e);
+    }
   }
-}
-
-function tileFeaturesRaster(_ref) {
-  let {
-    tiles,
-    ...options
-  } = _ref;
-  // Cache band metadata for faster lookup while iterating over pixels.
-  const bandMetadataByName = {};
-  for (const band of options.rasterMetadata.bands) {
-    bandMetadataByName[band.name] = band;
+  getTable(options) {
+    try {
+      const _this7 = this;
+      const {
+        filters = _this7.props.filters,
+        filterOwner,
+        spatialFilter,
+        spatialFiltersMode,
+        spatialIndexReferenceViewState,
+        abortController,
+        ...params
+      } = options;
+      const {
+        columns,
+        sortBy,
+        sortDirection,
+        offset = 0,
+        limit = 10
+      } = params;
+      const source = _this7.getModelSource(filters, filterOwner);
+      const spatialFiltersResolution = _this7._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
+      return Promise.resolve(executeModel({
+        model: 'table',
+        source: {
+          ...source,
+          spatialFiltersResolution,
+          spatialFiltersMode,
+          spatialFilter
+        },
+        params: {
+          column: columns,
+          sortBy,
+          sortDirection,
+          limit,
+          offset
+        },
+        opts: {
+          abortController,
+          headers: _this7._headers
+        }
+      }).then(res => ({
+        // Avoid `normalizeObjectKeys()`, which changes column names.
+        rows: res.rows ?? res.ROWS,
+        totalCount: res.metadata?.total ?? res.METADATA?.TOTAL
+      })));
+    } catch (e) {
+      return Promise.reject(e);
+    }
   }
-  // Omit empty and invisible tiles for simpler processing and types.
-  tiles = tiles.filter(isRasterTileVisible);
-  if (tiles.length === 0) return [];
-  // Raster tiles, and all pixels, are quadbin cells. Resolution of a pixel is
-  // the resolution of the tile, plus the number of subdivisions. Block size
-  // must be square, N x N, where N is a power of two.
-  const tileResolution = quadbin.getResolution(tiles[0].index.q);
-  const tileBlockSize = tiles[0].data.blockSize;
-  const cellResolution = tileResolution + BigInt(Math.log2(tileBlockSize));
-  // Compute covering cells for the spatial filter, at same resolution as the
-  // raster pixels, to be used as a mask.
-  const spatialFilterCells = new Set(quadbin.geometryToCells(options.spatialFilter, cellResolution));
-  const data = new Map();
-  for (const tile of tiles) {
-    const parent = tile.index.q;
-    const children = cellToChildrenSorted(parent, cellResolution);
-    // For each pixel/cell within the spatial filter, create a FeatureData.
-    // Order is row-major, starting from NW and ending at SE.
-    for (let i = 0; i < children.length; i++) {
-      if (!spatialFilterCells.has(children[i])) continue;
-      const cellData = {};
-      let cellDataExists = false;
-      for (const band in tile.data.cells.numericProps) {
-        const value = tile.data.cells.numericProps[band].value[i];
-        // TODO(cleanup): nodata should be a number, not a string.
-        if (Number(bandMetadataByName[band].nodata) !== value) {
-          cellData[band] = tile.data.cells.numericProps[band].value[i];
-          cellDataExists = true;
+  getTimeSeries(options) {
+    try {
+      const _this8 = this;
+      const {
+        filters = _this8.props.filters,
+        filterOwner,
+        abortController,
+        spatialFilter,
+        spatialFiltersMode,
+        spatialIndexReferenceViewState,
+        ...params
+      } = options;
+      const {
+        column,
+        operationColumn,
+        joinOperation,
+        operation,
+        stepSize,
+        stepMultiplier,
+        splitByCategory,
+        splitByCategoryLimit,
+        splitByCategoryValues
+      } = params;
+      const source = _this8.getModelSource(filters, filterOwner);
+      const spatialFiltersResolution = _this8._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
+      return Promise.resolve(executeModel({
+        model: 'timeseries',
+        source: {
+          ...source,
+          spatialFiltersResolution,
+          spatialFiltersMode,
+          spatialFilter
+        },
+        params: {
+          column,
+          stepSize,
+          stepMultiplier,
+          operationColumn: operationColumn || column,
+          joinOperation,
+          operation,
+          splitByCategory,
+          splitByCategoryLimit,
+          splitByCategoryValues
+        },
+        opts: {
+          abortController,
+          headers: _this8._headers
         }
-      }
-      if (cellDataExists) {
-        data.set(children[i], cellData);
-      }
+      }).then(res => ({
+        rows: normalizeObjectKeys(res.rows),
+        categories: res.metadata?.categories
+      })));
+    } catch (e) {
+      return Promise.reject(e);
     }
   }
-  return Array.from(data.values());
-}
-/**
- * Detects whether a given {@link Tile} is a {@link RasterTile}.
- * @privateRemarks Method of detection is arbitrary, and may be changed.
- */
-function isRasterTile(tile) {
-  return tile.data ? tile.data.hasOwnProperty('cells') : false;
-}
-function isRasterTileVisible(tile) {
-  return !!(tile.isVisible && tile.data?.cells?.numericProps);
 }
+
 /**
- * For the raster format, children are sorted in row-major order, starting from
- * NW and ending at SE. Order returned by quadbin's cellToChildren() is not
- * defined (and not related to the raster format), so sort explicitly here.
+ * Source for Widget API requests on a data source defined by a SQL query.
+ *
+ * Generally not intended to be constructed directly. Instead, call
+ * {@link vectorQuerySource}, {@link h3QuerySource}, or {@link quadbinQuerySource},
+ * which can be shared with map layers. Sources contain a `widgetSource` property,
+ * for use by widget implementations.
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { vectorQuerySource } from '@carto/api-client';
+ *
+ * const data = vectorQuerySource({
+ *   accessToken: '••••',
+ *   connectionName: 'carto_dw',
+ *   sqlQuery: 'SELECT * FROM carto-demo-data.demo_tables.retail_stores'
+ * });
+ *
+ * const { widgetSource } = await data;
+ * ```
  */
-function cellToChildrenSorted(parent, resolution) {
-  return quadbin.cellToChildren(parent, resolution).sort((cellA, cellB) => {
-    const tileA = quadbin.cellToTile(cellA);
-    const tileB = quadbin.cellToTile(cellB);
-    if (tileA.y !== tileB.y) {
-      return tileA.y > tileB.y ? 1 : -1;
-    }
-    return tileA.x > tileB.x ? 1 : -1;
-  });
-}
-
-/** @internalRemarks Source: @carto/react-core */
-function tileFeatures(_ref) {
-  let {
-    tiles,
-    spatialFilter,
-    uniqueIdProperty,
-    tileFormat,
-    spatialDataColumn = DEFAULT_GEO_COLUMN,
-    spatialDataType,
-    rasterMetadata,
-    options = {}
-  } = _ref;
-  // TODO(cleanup): Is an empty response the expected result when spatialFilter
-  // is omitted? Why not make the parameter required, or return the full input?
-  if (!spatialFilter) {
-    return [];
-  }
-  if (spatialDataType === 'geo') {
-    return tileFeaturesGeometries({
-      tiles,
-      tileFormat,
-      spatialFilter,
-      uniqueIdProperty,
-      options
-    });
-  }
-  if (tiles.some(isRasterTile)) {
-    assert$1(rasterMetadata, 'Missing raster metadata');
-    return tileFeaturesRaster({
-      tiles: tiles,
-      spatialFilter,
-      spatialDataColumn,
-      spatialDataType,
-      rasterMetadata
-    });
+class WidgetQuerySource extends WidgetRemoteSource {
+  getModelSource(filters, filterOwner) {
+    return {
+      ...super._getModelSource(filters, filterOwner),
+      type: 'query',
+      data: this.props.sqlQuery,
+      queryParameters: this.props.queryParameters
+    };
   }
-  return tileFeaturesSpatialIndex({
-    tiles: tiles,
-    spatialFilter,
-    spatialDataColumn,
-    spatialDataType
-  });
 }
 
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 const aggregationFunctions = {
   count: values => values.length,
   min: function () {
@@ -2413,7 +2540,7 @@ const aggregationFunctions = {
     return applyAggregationFunction(avg, ...[].slice.call(arguments));
   }
 };
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function aggregate(feature, keys, operation) {
   if (!keys?.length) {
     throw new Error('Cannot aggregate a feature without having keys');
@@ -2562,7 +2689,7 @@ var thenBy_module = function () {
  * @param [sortOptions.sortByDirection] - Direction by the columns will be sorted
  * @param [sortOptions.sortByColumnType] - Column type
  * @internal
- * @internalRemarks Source: @carto/react-core
+ * @privateRemarks Source: @carto/react-core
  */
 function applySorting(features, _temp) {
   let {
@@ -2601,7 +2728,7 @@ function createSortFn(_ref) {
     sortByColumnType
   });
   let sortFn = thenBy_module.firstBy(...firstSortOption);
-  for (let sortOptions of othersSortOptions) {
+  for (const sortOptions of othersSortOptions) {
     sortFn = sortFn.thenBy(...sortOptions);
   }
   return sortFn;
@@ -2650,7 +2777,7 @@ function normalizeSortByOptions(_ref2) {
   });
 }
 
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function groupValuesByColumn(_ref) {
   let {
     data,
@@ -2712,7 +2839,7 @@ const GROUP_KEY_FN_MAPPING = {
   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())
 };
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function groupValuesByDateColumn(_ref) {
   let {
     data,
@@ -2760,7 +2887,7 @@ function groupValuesByDateColumn(_ref) {
 
 /**
  * Histogram computation.
- * @internalRemarks Source: @carto/react-core
+ * @privateRemarks Source: @carto/react-core
  */
 function histogram(_ref) {
   let {
@@ -2798,7 +2925,7 @@ function histogram(_ref) {
 
 /**
  * Filters invalid features and formats  data.
- * @internalRemarks Source: @carto/react-core
+ * @privateRemarks Source: @carto/react-core
  */
 function scatterPlot(_ref) {
   let {
@@ -2847,10 +2974,12 @@ class WidgetTilesetSource extends WidgetSource {
     super(...arguments);
     this._tiles = [];
     this._features = [];
+    this._tileFeatureExtractOptions = {};
+    this._tileFeatureExtractPreviousInputs = {};
   }
-  getModelSource(owner) {
+  getModelSource(filters, filterOwner) {
     return {
-      ...super._getModelSource(owner),
+      ...super._getModelSource(filters, filterOwner),
       type: 'tileset',
       data: this.props.tableName
     };
@@ -2862,39 +2991,46 @@ class WidgetTilesetSource extends WidgetSource {
    */
   loadTiles(tiles) {
     this._tiles = tiles;
-  }
-  /**
-   * Extracts feature data from tiles previously loaded with {@link loadTiles}.
-   * Must be called before computing statistics on tiles.
-   */
-  extractTileFeatures(_ref) {
-    let {
-      spatialFilter,
-      uniqueIdProperty,
-      options
-    } = _ref;
+    this._features.length = 0;
+  }
+  /** Configures options used to extract features from tiles. */
+  setTileFeatureExtractOptions(options) {
+    this._tileFeatureExtractOptions = options;
+    this._features.length = 0;
+  }
+  _extractTileFeatures(spatialFilter) {
+    // When spatial filter has not changed, don't redo extraction. If tiles or
+    // tile extract options change, features will have been cleared already.
+    const prevInputs = this._tileFeatureExtractPreviousInputs;
+    if (this._features.length && prevInputs.spatialFilter && booleanEqual.booleanEqual(prevInputs.spatialFilter, spatialFilter)) {
+      return;
+    }
     this._features = tileFeatures({
+      ...this.props,
+      ...this._tileFeatureExtractOptions,
       tiles: this._tiles,
-      options,
-      spatialFilter,
-      uniqueIdProperty,
-      ...this.props
+      spatialFilter
     });
+    prevInputs.spatialFilter = spatialFilter;
   }
-  /** Loads features as GeoJSON (used for testing). */
-  loadGeoJSON(_ref2) {
+  /**
+   * Loads features as GeoJSON (used for testing).
+   * @experimental
+   * @internal Not for public use. Spatial filters in other method calls will be ignored.
+   */
+  loadGeoJSON(_ref) {
     let {
       geojson,
-      spatialFilter,
-      uniqueIdProperty
-    } = _ref2;
+      spatialFilter
+    } = _ref;
     this._features = geojsonFeatures({
       geojson,
       spatialFilter,
-      uniqueIdProperty
+      ...this._tileFeatureExtractOptions
     });
+    this._tileFeatureExtractPreviousInputs.spatialFilter = spatialFilter;
   }
-  getFeatures(options) {
+  getFeatures() {
     try {
       throw new Error('getFeatures not supported for tilesets');
       return Promise.resolve();
@@ -2902,28 +3038,25 @@ class WidgetTilesetSource extends WidgetSource {
       return Promise.reject(e);
     }
   }
-  getFormula(_ref3) {
+  getFormula(_ref2) {
     let {
       column = '*',
       operation = 'count',
       joinOperation,
-      filterOwner
-    } = _ref3;
+      filters,
+      filterOwner,
+      spatialFilter
+    } = _ref2;
     try {
       const _this = this;
       if (operation === 'custom') {
         throw new Error('Custom aggregation not supported for tilesets');
       }
-      if (!_this._features.length) {
-        return Promise.resolve({
-          value: null
-        });
-      }
       // Column is required except when operation is 'count'.
       if (column && column !== '*' || operation !== 'count') {
         assertColumn(_this._features, column);
       }
-      const filteredFeatures = _this._getFilteredFeatures(filterOwner);
+      const filteredFeatures = _this._getFilteredFeatures(spatialFilter, filters, filterOwner);
       if (filteredFeatures.length === 0 && operation !== 'count') {
         return Promise.resolve({
           value: null
@@ -2937,21 +3070,23 @@ class WidgetTilesetSource extends WidgetSource {
       return Promise.reject(e);
     }
   }
-  getHistogram(_ref4) {
+  getHistogram(_ref3) {
     let {
       operation = 'count',
       ticks,
       column,
       joinOperation,
-      filterOwner
-    } = _ref4;
+      filters,
+      filterOwner,
+      spatialFilter
+    } = _ref3;
     try {
       const _this2 = this;
+      const filteredFeatures = _this2._getFilteredFeatures(spatialFilter, filters, filterOwner);
+      assertColumn(_this2._features, column);
       if (!_this2._features.length) {
         return Promise.resolve([]);
       }
-      const filteredFeatures = _this2._getFilteredFeatures(filterOwner);
-      assertColumn(_this2._features, column);
       return Promise.resolve(histogram({
         data: filteredFeatures,
         valuesColumns: normalizeColumns(column),
@@ -2963,20 +3098,22 @@ class WidgetTilesetSource extends WidgetSource {
       return Promise.reject(e);
     }
   }
-  getCategories(_ref5) {
+  getCategories(_ref4) {
     let {
       column,
       operation = 'count',
       operationColumn,
       joinOperation,
-      filterOwner
-    } = _ref5;
+      filters,
+      filterOwner,
+      spatialFilter
+    } = _ref4;
     try {
       const _this3 = this;
-      if (!_this3._features.length) {
+      const filteredFeatures = _this3._getFilteredFeatures(spatialFilter, filters, filterOwner);
+      if (!filteredFeatures.length) {
         return Promise.resolve([]);
       }
-      const filteredFeatures = _this3._getFilteredFeatures(filterOwner);
       assertColumn(_this3._features, column, operationColumn);
       const groups = groupValuesByColumn({
         data: filteredFeatures,
@@ -2990,20 +3127,22 @@ class WidgetTilesetSource extends WidgetSource {
       return Promise.reject(e);
     }
   }
-  getScatter(_ref6) {
+  getScatter(_ref5) {
     let {
       xAxisColumn,
       yAxisColumn,
       xAxisJoinOperation,
       yAxisJoinOperation,
-      filterOwner
-    } = _ref6;
+      filters,
+      filterOwner,
+      spatialFilter
+    } = _ref5;
     try {
       const _this4 = this;
-      if (!_this4._features.length) {
+      const filteredFeatures = _this4._getFilteredFeatures(spatialFilter, filters, filterOwner);
+      if (!filteredFeatures.length) {
         return Promise.resolve([]);
       }
-      const filteredFeatures = _this4._getFilteredFeatures(filterOwner);
       assertColumn(_this4._features, xAxisColumn, yAxisColumn);
       return Promise.resolve(scatterPlot({
         data: filteredFeatures,
@@ -3016,35 +3155,31 @@ class WidgetTilesetSource extends WidgetSource {
       return Promise.reject(e);
     }
   }
-  getTable(options) {
+  getTable(_ref6) {
+    let {
+      columns,
+      searchFilterColumn,
+      searchFilterText,
+      sortBy,
+      sortDirection,
+      sortByColumnType,
+      offset = 0,
+      limit = 10,
+      filters,
+      filterOwner,
+      spatialFilter
+    } = _ref6;
     try {
       const _this5 = this;
-      const {
-        filterOwner,
-        spatialFilter,
-        abortController,
-        ...params
-      } = options;
-      const {
-        columns,
-        searchFilterColumn,
-        searchFilterText,
-        sortBy,
-        sortDirection,
-        sortByColumnType,
-        offset = 0,
-        limit = 10
-      } = params;
-      if (!_this5._features.length) {
+      // Filter.
+      let filteredFeatures = _this5._getFilteredFeatures(spatialFilter, filters, filterOwner);
+      if (!filteredFeatures.length) {
         return Promise.resolve({
           rows: [],
           totalCount: 0
         });
       }
-      // Filter.
-      let filteredFeatures = _this5._getFilteredFeatures(filterOwner);
       // Search.
-      // TODO: Could we get the same behavior by applying filters in loadTiles()?
       if (searchFilterColumn && searchFilterText) {
         filteredFeatures = filteredFeatures.filter(row => row[searchFilterColumn] && String(row[searchFilterColumn]).toLowerCase().includes(String(searchFilterText).toLowerCase()));
       }
@@ -3080,16 +3215,18 @@ class WidgetTilesetSource extends WidgetSource {
       operation,
       operationColumn,
       joinOperation,
-      filterOwner
+      filters,
+      filterOwner,
+      spatialFilter
     } = _ref7;
     try {
       const _this6 = this;
-      if (!_this6._features.length) {
+      const filteredFeatures = _this6._getFilteredFeatures(spatialFilter, filters, filterOwner);
+      if (!filteredFeatures.length) {
         return Promise.resolve({
           rows: []
         });
       }
-      const filteredFeatures = _this6._getFilteredFeatures(filterOwner);
       assertColumn(_this6._features, column, operationColumn);
       const rows = groupValuesByDateColumn({
         data: filteredFeatures,
@@ -3109,17 +3246,19 @@ class WidgetTilesetSource extends WidgetSource {
   getRange(_ref8) {
     let {
       column,
-      filterOwner
+      filters,
+      filterOwner,
+      spatialFilter
     } = _ref8;
     try {
       const _this7 = this;
+      assertColumn(_this7._features, column);
+      const filteredFeatures = _this7._getFilteredFeatures(spatialFilter, filters, filterOwner);
       if (!_this7._features.length) {
         // TODO: Is this the only nullable response in the Widgets API? If so,
         // can we do something more consistent?
         return Promise.resolve(null);
       }
-      assertColumn(_this7._features, column);
-      const filteredFeatures = _this7._getFilteredFeatures(filterOwner);
       return Promise.resolve({
         min: aggregationFunctions.min(filteredFeatures, column),
         max: aggregationFunctions.max(filteredFeatures, column)
@@ -3131,8 +3270,10 @@ class WidgetTilesetSource extends WidgetSource {
   /****************************************************************************
    * INTERNAL
    */
-  _getFilteredFeatures(filterOwner) {
-    return applyFilters(this._features, getApplicableFilters(filterOwner, this.props.filters), this.props.filtersLogicalOperator || 'and');
+  _getFilteredFeatures(spatialFilter, filters, filterOwner) {
+    assert(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) {
@@ -3174,9 +3315,9 @@ class WidgetRasterSource extends WidgetTilesetSource {}
  * ```
  */
 class WidgetTableSource extends WidgetRemoteSource {
-  getModelSource(owner) {
+  getModelSource(filters, filterOwner) {
     return {
-      ...super._getModelSource(owner),
+      ...super._getModelSource(filters, filterOwner),
       type: 'table',
       data: this.props.tableName
     };
@@ -3186,7 +3327,6 @@ class WidgetTableSource extends WidgetRemoteSource {
 // deck.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-/* eslint-disable camelcase */
 const h3QuerySource = function (options) {
   try {
     const {
@@ -3230,7 +3370,6 @@ const h3QuerySource = function (options) {
 // deck.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-/* eslint-disable camelcase */
 const h3TableSource = function (options) {
   try {
     const {
@@ -3331,7 +3470,6 @@ const rasterSource = function (options) {
 // deck.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-/* eslint-disable camelcase */
 const quadbinQuerySource = function (options) {
   try {
     const {
@@ -3375,7 +3513,6 @@ const quadbinQuerySource = function (options) {
 // deck.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-/* eslint-disable camelcase */
 const quadbinTableSource = function (options) {
   try {
     const {
@@ -3441,7 +3578,6 @@ const quadbinTilesetSource = function (options) {
 // deck.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-/* eslint-disable camelcase */
 const vectorQuerySource = function (options) {
   try {
     const {
@@ -3490,7 +3626,6 @@ const vectorQuerySource = function (options) {
 // deck.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-/* eslint-disable camelcase */
 const vectorTableSource = function (options) {
   try {
     const {
@@ -3619,6 +3754,7 @@ exports.WidgetRemoteSource = WidgetRemoteSource;
 exports.WidgetSource = WidgetSource;
 exports.WidgetTableSource = WidgetTableSource;
 exports.WidgetTilesetSource = WidgetTilesetSource;
+exports._buildFeatureFilter = _buildFeatureFilter;
 exports._getHexagonResolution = _getHexagonResolution;
 exports.addFilter = addFilter;
 exports.aggregate = aggregate;
@@ -3628,7 +3764,6 @@ exports.applySorting = applySorting;
 exports.boundaryQuerySource = boundaryQuerySource;
 exports.boundaryTableSource = boundaryTableSource;
 exports.buildBinaryFeatureFilter = buildBinaryFeatureFilter;
-exports.buildFeatureFilter = buildFeatureFilter;
 exports.buildPublicMapUrl = buildPublicMapUrl;
 exports.buildStatsUrl = buildStatsUrl;
 exports.clearFilters = clearFilters;
@@ -3637,6 +3772,7 @@ exports.createViewportSpatialFilter = createViewportSpatialFilter;
 exports.filterFunctions = filterFunctions;
 exports.geojsonFeatures = geojsonFeatures;
 exports.getClient = getClient;
+exports.getDataFilterExtensionProps = getDataFilterExtensionProps;
 exports.getFilter = getFilter;
 exports.groupValuesByColumn = groupValuesByColumn;
 exports.groupValuesByDateColumn = groupValuesByDateColumn;