@carto/api-client 0.5.7-alpha.6 → 0.5.8-alpha-others-orderby.1

package/build/worker-compat.js

@@ -1513,6 +1513,110 @@
     return Array.from(map.values());
   }
 
+  // node_modules/@math.gl/core/dist/lib/common.js
+  var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
+  var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
+  var DEFAULT_CONFIG = {
+    EPSILON: 1e-12,
+    debug: false,
+    precision: 4,
+    printTypes: false,
+    printDegrees: false,
+    printRowMajor: true,
+    _cartographicRadians: false
+  };
+  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
+  var config = globalThis.mathgl.config;
+  function isArray(value) {
+    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+  }
+  function lerp(a, b, t) {
+    if (isArray(a)) {
+      return a.map((ai, i) => lerp(ai, b[i], t));
+    }
+    return t * b + (1 - t) * a;
+  }
+
+  // node_modules/@math.gl/web-mercator/dist/assert.js
+  function assert2(condition, message) {
+    if (!condition) {
+      throw new Error(message || "@math.gl/web-mercator: assertion failed.");
+    }
+  }
+
+  // node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js
+  var PI = Math.PI;
+  var PI_4 = PI / 4;
+  var DEGREES_TO_RADIANS2 = PI / 180;
+  var RADIANS_TO_DEGREES2 = 180 / PI;
+  var TILE_SIZE = 512;
+  function lngLatToWorld(lngLat) {
+    const [lng, lat] = lngLat;
+    assert2(Number.isFinite(lng));
+    assert2(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude");
+    const lambda2 = lng * DEGREES_TO_RADIANS2;
+    const phi2 = lat * DEGREES_TO_RADIANS2;
+    const x = TILE_SIZE * (lambda2 + PI) / (2 * PI);
+    const y = TILE_SIZE * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5))) / (2 * PI);
+    return [x, y];
+  }
+  function worldToLngLat(xy) {
+    const [x, y] = xy;
+    const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
+    const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
+    return [lambda2 * RADIANS_TO_DEGREES2, phi2 * RADIANS_TO_DEGREES2];
+  }
+
+  // node_modules/@math.gl/web-mercator/dist/get-bounds.js
+  var DEGREES_TO_RADIANS3 = Math.PI / 180;
+
+  // src/utils/transformTileCoordsToWGS84.ts
+  var TRANSFORM_FN = {
+    Point: transformPoint,
+    MultiPoint: transformMultiPoint,
+    LineString: transformLineString,
+    MultiLineString: transformMultiLineString,
+    Polygon: transformPolygon,
+    MultiPolygon: transformMultiPolygon
+  };
+  function transformTileCoordsToWGS84(geometry, bbox2) {
+    const [west, south, east, north] = bbox2;
+    const nw = 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 transformPoint([pointX, pointY], [nw, se]) {
+    const x = lerp(nw[0], se[0], pointX);
+    const y = lerp(nw[1], se[1], pointY);
+    return worldToLngLat([x, y]);
+  }
+  function getPoints(geometry, bbox2) {
+    return geometry.map((g) => transformPoint(g, bbox2));
+  }
+  function transformMultiPoint(multiPoint, bbox2) {
+    return getPoints(multiPoint, bbox2);
+  }
+  function transformLineString(line, bbox2) {
+    return getPoints(line, bbox2);
+  }
+  function transformMultiLineString(multiLineString2, bbox2) {
+    return multiLineString2.map(
+      (lineString2) => transformLineString(lineString2, bbox2)
+    );
+  }
+  function transformPolygon(polygon2, bbox2) {
+    return polygon2.map((polygonRing) => getPoints(polygonRing, bbox2));
+  }
+  function transformMultiPolygon(multiPolygon2, bbox2) {
+    return multiPolygon2.map((polygon2) => transformPolygon(polygon2, bbox2));
+  }
+
   // node_modules/@turf/bbox-polygon/dist/esm/index.js
   function bboxPolygon(bbox2, options = {}) {
     const west = Number(bbox2[0]);
@@ -1831,7 +1935,7 @@
   var POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13];
   var SQRT_BASE = 1e7;
   var MAX = 1e9;
-  function clone(configObject) {
+  function clone2(configObject) {
     var div, convertBase, parseNumeric, P = BigNumber2.prototype = { constructor: BigNumber2, toString: null, valueOf: null }, ONE = new BigNumber2(1), DECIMAL_PLACES = 20, ROUNDING_MODE = 4, TO_EXP_NEG = -7, TO_EXP_POS = 21, MIN_EXP = -1e7, MAX_EXP = 1e7, CRYPTO = false, MODULO_MODE = 1, POW_PRECISION = 0, FORMAT = {
       prefix: "",
       groupSize: 3,
@@ -1957,7 +2061,7 @@
         x.c = [x.e = 0];
       }
     }
-    BigNumber2.clone = clone;
+    BigNumber2.clone = clone2;
     BigNumber2.ROUND_UP = 0;
     BigNumber2.ROUND_DOWN = 1;
     BigNumber2.ROUND_CEIL = 2;
@@ -3160,7 +3264,7 @@
     }
     return str;
   }
-  var BigNumber = clone();
+  var BigNumber = clone2();
   var bignumber_default = BigNumber;
 
   // node_modules/splaytree-ts/dist/esm/index.js
@@ -4729,117 +4833,7 @@
   }
   var turf_intersect_default = intersect;
 
-  // node_modules/@math.gl/core/dist/lib/common.js
-  var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
-  var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
-  var DEFAULT_CONFIG = {
-    EPSILON: 1e-12,
-    debug: false,
-    precision: 4,
-    printTypes: false,
-    printDegrees: false,
-    printRowMajor: true,
-    _cartographicRadians: false
-  };
-  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
-  var config = globalThis.mathgl.config;
-  function isArray(value) {
-    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
-  }
-  function lerp(a, b, t) {
-    if (isArray(a)) {
-      return a.map((ai, i) => lerp(ai, b[i], t));
-    }
-    return t * b + (1 - t) * a;
-  }
-
-  // node_modules/@math.gl/web-mercator/dist/assert.js
-  function assert2(condition, message) {
-    if (!condition) {
-      throw new Error(message || "@math.gl/web-mercator: assertion failed.");
-    }
-  }
-
-  // node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js
-  var PI = Math.PI;
-  var PI_4 = PI / 4;
-  var DEGREES_TO_RADIANS2 = PI / 180;
-  var RADIANS_TO_DEGREES2 = 180 / PI;
-  var TILE_SIZE = 512;
-  function lngLatToWorld(lngLat) {
-    const [lng, lat] = lngLat;
-    assert2(Number.isFinite(lng));
-    assert2(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude");
-    const lambda2 = lng * DEGREES_TO_RADIANS2;
-    const phi2 = lat * DEGREES_TO_RADIANS2;
-    const x = TILE_SIZE * (lambda2 + PI) / (2 * PI);
-    const y = TILE_SIZE * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5))) / (2 * PI);
-    return [x, y];
-  }
-  function worldToLngLat(xy) {
-    const [x, y] = xy;
-    const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
-    const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
-    return [lambda2 * RADIANS_TO_DEGREES2, phi2 * RADIANS_TO_DEGREES2];
-  }
-
-  // node_modules/@math.gl/web-mercator/dist/get-bounds.js
-  var DEGREES_TO_RADIANS3 = Math.PI / 180;
-
   // src/utils/transformToTileCoords.ts
-  var TRANSFORM_FN = {
-    Point: transformPoint,
-    MultiPoint: transformMultiPoint,
-    LineString: transformLineString,
-    MultiLineString: transformMultiLineString,
-    Polygon: transformPolygon,
-    MultiPolygon: transformMultiPolygon
-  };
-  function transformToTileCoords(geometry, bbox2) {
-    const [west, south, east, north] = bbox2;
-    const nw = projectFlat([west, north]);
-    const se = projectFlat([east, south]);
-    const projectedBbox = [nw, se];
-    if (geometry.type === "GeometryCollection") {
-      throw new Error("Unsupported geometry type GeometryCollection");
-    }
-    const transformFn = TRANSFORM_FN[geometry.type];
-    const coordinates = transformFn(geometry.coordinates, projectedBbox);
-    return { ...geometry, coordinates };
-  }
-  function transformPoint([pointX, pointY], [nw, se]) {
-    const x = inverseLerp(nw[0], se[0], pointX);
-    const y = inverseLerp(nw[1], se[1], pointY);
-    return [x, y];
-  }
-  function getPoints(geometry, bbox2) {
-    return geometry.map((g) => transformPoint(projectFlat(g), bbox2));
-  }
-  function transformMultiPoint(multiPoint, bbox2) {
-    return getPoints(multiPoint, bbox2);
-  }
-  function transformLineString(line, bbox2) {
-    return getPoints(line, bbox2);
-  }
-  function transformMultiLineString(multiLineString2, bbox2) {
-    return multiLineString2.map(
-      (lineString2) => transformLineString(lineString2, bbox2)
-    );
-  }
-  function transformPolygon(polygon2, bbox2) {
-    return polygon2.map((polygonRing) => getPoints(polygonRing, bbox2));
-  }
-  function transformMultiPolygon(multiPolygon2, bbox2) {
-    return multiPolygon2.map((polygon2) => transformPolygon(polygon2, bbox2));
-  }
-  function projectFlat(xyz) {
-    return lngLatToWorld(xyz);
-  }
-  function inverseLerp(a, b, x) {
-    return (x - a) / (b - a);
-  }
-
-  // src/utils/transformTileCoordsToWGS84.ts
   var TRANSFORM_FN2 = {
     Point: transformPoint2,
     MultiPoint: transformMultiPoint2,
@@ -4848,10 +4842,10 @@
     Polygon: transformPolygon2,
     MultiPolygon: transformMultiPolygon2
   };
-  function transformTileCoordsToWGS84(geometry, bbox2) {
+  function transformToTileCoords(geometry, bbox2) {
     const [west, south, east, north] = bbox2;
-    const nw = lngLatToWorld([west, north]);
-    const se = lngLatToWorld([east, south]);
+    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");
@@ -4861,12 +4855,12 @@
     return { ...geometry, coordinates };
   }
   function transformPoint2([pointX, pointY], [nw, se]) {
-    const x = lerp(nw[0], se[0], pointX);
-    const y = lerp(nw[1], se[1], pointY);
-    return worldToLngLat([x, y]);
+    const x = inverseLerp(nw[0], se[0], pointX);
+    const y = inverseLerp(nw[1], se[1], pointY);
+    return [x, y];
   }
   function getPoints2(geometry, bbox2) {
-    return geometry.map((g) => transformPoint2(g, bbox2));
+    return geometry.map((g) => transformPoint2(projectFlat(g), bbox2));
   }
   function transformMultiPoint2(multiPoint, bbox2) {
     return getPoints2(multiPoint, bbox2);
@@ -4885,298 +4879,12 @@
   function transformMultiPolygon2(multiPolygon2, bbox2) {
     return multiPolygon2.map((polygon2) => transformPolygon2(polygon2, bbox2));
   }
-
-  // src/filters/tileFeaturesGeometries.ts
-  var FEATURE_GEOM_PROPERTY = "__geomValue";
-  function tileFeaturesGeometries({
-    tiles: tiles2,
-    tileFormat,
-    spatialFilter,
-    uniqueIdProperty,
-    options
-  }) {
-    const map = /* @__PURE__ */ new Map();
-    for (const tile of tiles2) {
-      if (tile.isVisible === false || !tile.data) {
-        continue;
-      }
-      const bbox2 = [
-        tile.bbox.west,
-        tile.bbox.south,
-        tile.bbox.east,
-        tile.bbox.north
-      ];
-      const bboxToGeom = turf_bbox_polygon_default(bbox2);
-      const tileIsFullyVisible = turf_boolean_within_default(bboxToGeom, spatialFilter);
-      const spatialFilterFeature = {
-        type: "Feature",
-        geometry: spatialFilter,
-        properties: {}
-      };
-      const clippedGeometryToIntersect = turf_intersect_default(
-        featureCollection([bboxToGeom, spatialFilterFeature])
-      );
-      if (!clippedGeometryToIntersect) {
-        continue;
-      }
-      const transformedGeometryToIntersect = tileFormat === "mvt" /* MVT */ ? transformToTileCoords(clippedGeometryToIntersect.geometry, bbox2) : clippedGeometryToIntersect.geometry;
-      calculateFeatures({
-        map,
-        tileIsFullyVisible,
-        geometryIntersection: transformedGeometryToIntersect,
-        data: tile.data.points,
-        type: "Point",
-        bbox: bbox2,
-        tileFormat,
-        uniqueIdProperty,
-        options
-      });
-      calculateFeatures({
-        map,
-        tileIsFullyVisible,
-        geometryIntersection: transformedGeometryToIntersect,
-        data: tile.data.lines,
-        type: "LineString",
-        bbox: bbox2,
-        tileFormat,
-        uniqueIdProperty,
-        options
-      });
-      calculateFeatures({
-        map,
-        tileIsFullyVisible,
-        geometryIntersection: transformedGeometryToIntersect,
-        data: tile.data.polygons,
-        type: "Polygon",
-        bbox: bbox2,
-        tileFormat,
-        uniqueIdProperty,
-        options
-      });
-    }
-    return Array.from(map.values());
-  }
-  function processTileFeatureProperties({
-    map,
-    data,
-    startIndex,
-    endIndex,
-    type,
-    bbox: bbox2,
-    tileFormat,
-    uniqueIdProperty,
-    storeGeometry,
-    geometryIntersection
-  }) {
-    const tileProps = getPropertiesFromTile(data, startIndex);
-    const uniquePropertyValue = getUniquePropertyValue(
-      tileProps,
-      uniqueIdProperty,
-      map
-    );
-    if (!uniquePropertyValue || map.has(uniquePropertyValue)) {
-      return;
-    }
-    let geometry = null;
-    if (storeGeometry || geometryIntersection) {
-      const { positions } = data;
-      const ringCoordinates = getRingCoordinatesFor(
-        startIndex,
-        endIndex,
-        positions
-      );
-      geometry = getFeatureByType(ringCoordinates, type);
-    }
-    if (geometry && geometryIntersection && !turf_boolean_intersects_default(geometry, geometryIntersection)) {
-      return;
-    }
-    const properties = parseProperties(tileProps);
-    if (storeGeometry && geometry) {
-      properties[FEATURE_GEOM_PROPERTY] = tileFormat === "mvt" /* MVT */ ? transformTileCoordsToWGS84(geometry, bbox2) : geometry;
-    }
-    map.set(uniquePropertyValue, properties);
-  }
-  function addIntersectedFeaturesInTile({
-    map,
-    data,
-    geometryIntersection,
-    type,
-    bbox: bbox2,
-    tileFormat,
-    uniqueIdProperty,
-    options
-  }) {
-    const indices = getIndices(data, type);
-    const storeGeometry = options?.storeGeometry || false;
-    for (let i = 0; i < indices.length - 1; i++) {
-      const startIndex = indices[i];
-      const endIndex = indices[i + 1];
-      processTileFeatureProperties({
-        map,
-        data,
-        startIndex,
-        endIndex,
-        type,
-        bbox: bbox2,
-        tileFormat,
-        uniqueIdProperty,
-        storeGeometry,
-        geometryIntersection
-      });
-    }
-  }
-  function getIndices(data, type) {
-    let indices;
-    switch (type) {
-      case "Polygon":
-        indices = data.primitivePolygonIndices;
-        break;
-      case "LineString":
-        indices = data.pathIndices;
-        break;
-      case "Point":
-        indices = createIndicesForPoints(data);
-        break;
-      default:
-        throw new Error(
-          `Unsupported geometry type: ${type}`
-        );
-    }
-    return indices.value;
-  }
-  function getFeatureId(data, startIndex) {
-    return data.featureIds.value[startIndex];
-  }
-  function getPropertiesFromTile(data, startIndex) {
-    const featureId2 = getFeatureId(data, startIndex);
-    const { properties, numericProps, fields } = data;
-    const result = {
-      uniqueId: fields?.[featureId2]?.id,
-      properties: properties[featureId2],
-      numericProps: {}
-    };
-    for (const key in numericProps) {
-      result.numericProps[key] = numericProps[key].value[startIndex];
-    }
-    return result;
-  }
-  function parseProperties(tileProps) {
-    const { properties, numericProps } = tileProps;
-    return Object.assign({}, properties, numericProps);
-  }
-  function getUniquePropertyValue(tileProps, uniqueIdProperty, map) {
-    if (uniqueIdProperty) {
-      return getValueFromTileProps(tileProps, uniqueIdProperty);
-    }
-    if (tileProps.uniqueId) {
-      return tileProps.uniqueId;
-    }
-    const artificialId = map.size + 1;
-    return getValueFromTileProps(tileProps, "cartodb_id") || getValueFromTileProps(tileProps, "geoid") || artificialId;
-  }
-  function getValueFromTileProps(tileProps, propertyName) {
-    const { properties, numericProps } = tileProps;
-    return numericProps[propertyName] || properties[propertyName];
-  }
-  function getFeatureByType(coordinates, type) {
-    switch (type) {
-      case "Polygon":
-        return { type: "Polygon", coordinates: [coordinates] };
-      case "LineString":
-        return { type: "LineString", coordinates };
-      case "Point":
-        return { type: "Point", coordinates: coordinates[0] };
-      default:
-        throw new Error("Invalid geometry type");
-    }
-  }
-  function getRingCoordinatesFor(startIndex, endIndex, positions) {
-    const ringCoordinates = [];
-    for (let j = startIndex; j < endIndex; j++) {
-      ringCoordinates.push(
-        Array.from(
-          positions.value.subarray(j * positions.size, (j + 1) * positions.size)
-        )
-      );
-    }
-    return ringCoordinates;
-  }
-  function calculateFeatures({
-    map,
-    tileIsFullyVisible,
-    geometryIntersection,
-    data,
-    type,
-    bbox: bbox2,
-    tileFormat,
-    uniqueIdProperty,
-    options
-  }) {
-    if (!data?.properties.length) {
-      return;
-    }
-    if (tileIsFullyVisible) {
-      addAllFeaturesInTile({
-        map,
-        data,
-        type,
-        bbox: bbox2,
-        tileFormat,
-        uniqueIdProperty,
-        options
-      });
-    } else {
-      addIntersectedFeaturesInTile({
-        map,
-        data,
-        geometryIntersection,
-        type,
-        bbox: bbox2,
-        tileFormat,
-        uniqueIdProperty,
-        options
-      });
-    }
-  }
-  function addAllFeaturesInTile({
-    map,
-    data,
-    type,
-    bbox: bbox2,
-    tileFormat,
-    uniqueIdProperty,
-    options
-  }) {
-    const indices = getIndices(data, type);
-    const storeGeometry = options?.storeGeometry || false;
-    for (let i = 0; i < indices.length - 1; i++) {
-      const startIndex = indices[i];
-      const endIndex = indices[i + 1];
-      processTileFeatureProperties({
-        map,
-        data,
-        startIndex,
-        endIndex,
-        type,
-        bbox: bbox2,
-        tileFormat,
-        uniqueIdProperty,
-        storeGeometry
-      });
-    }
-  }
-  function createIndicesForPoints(data) {
-    const featureIds = data.featureIds.value;
-    const lastFeatureId = featureIds[featureIds.length - 1];
-    const PointIndicesArray = featureIds.constructor;
-    const pointIndices = {
-      value: new PointIndicesArray(featureIds.length + 1),
-      size: 1
-    };
-    pointIndices.value.set(featureIds);
-    pointIndices.value.set([lastFeatureId + 1], featureIds.length);
-    return pointIndices;
-  }
+  function projectFlat(xyz) {
+    return lngLatToWorld(xyz);
+  }
+  function inverseLerp(a, b, x) {
+    return (x - a) / (b - a);
+  }
 
   // node_modules/quadbin/dist/index.esm.js
   var d2r = Math.PI / 180;
@@ -5569,124 +5277,6 @@
     };
   }
 
-  // node_modules/@turf/bbox-clip/dist/esm/index.js
-  function lineclip(points, bbox2, result) {
-    var len = points.length, codeA = bitCode(points[0], bbox2), part = [], i, codeB, lastCode;
-    let a;
-    let b;
-    if (!result) result = [];
-    for (i = 1; i < len; i++) {
-      a = points[i - 1];
-      b = points[i];
-      codeB = lastCode = bitCode(b, bbox2);
-      while (true) {
-        if (!(codeA | codeB)) {
-          part.push(a);
-          if (codeB !== lastCode) {
-            part.push(b);
-            if (i < len - 1) {
-              result.push(part);
-              part = [];
-            }
-          } else if (i === len - 1) {
-            part.push(b);
-          }
-          break;
-        } else if (codeA & codeB) {
-          break;
-        } else if (codeA) {
-          a = intersect2(a, b, codeA, bbox2);
-          codeA = bitCode(a, bbox2);
-        } else {
-          b = intersect2(a, b, codeB, bbox2);
-          codeB = bitCode(b, bbox2);
-        }
-      }
-      codeA = lastCode;
-    }
-    if (part.length) result.push(part);
-    return result;
-  }
-  function polygonclip(points, bbox2) {
-    var result, edge, prev, prevInside, i, p, inside;
-    for (edge = 1; edge <= 8; edge *= 2) {
-      result = [];
-      prev = points[points.length - 1];
-      prevInside = !(bitCode(prev, bbox2) & edge);
-      for (i = 0; i < points.length; i++) {
-        p = points[i];
-        inside = !(bitCode(p, bbox2) & edge);
-        if (inside !== prevInside) result.push(intersect2(prev, p, edge, bbox2));
-        if (inside) result.push(p);
-        prev = p;
-        prevInside = inside;
-      }
-      points = result;
-      if (!points.length) break;
-    }
-    return result;
-  }
-  function intersect2(a, b, edge, bbox2) {
-    return edge & 8 ? [a[0] + (b[0] - a[0]) * (bbox2[3] - a[1]) / (b[1] - a[1]), bbox2[3]] : edge & 4 ? [a[0] + (b[0] - a[0]) * (bbox2[1] - a[1]) / (b[1] - a[1]), bbox2[1]] : edge & 2 ? [bbox2[2], a[1] + (b[1] - a[1]) * (bbox2[2] - a[0]) / (b[0] - a[0])] : edge & 1 ? [bbox2[0], a[1] + (b[1] - a[1]) * (bbox2[0] - a[0]) / (b[0] - a[0])] : null;
-  }
-  function bitCode(p, bbox2) {
-    var code = 0;
-    if (p[0] < bbox2[0]) code |= 1;
-    else if (p[0] > bbox2[2]) code |= 2;
-    if (p[1] < bbox2[1]) code |= 4;
-    else if (p[1] > bbox2[3]) code |= 8;
-    return code;
-  }
-  function bboxClip(feature2, bbox2) {
-    const geom = getGeom(feature2);
-    const type = geom.type;
-    const properties = feature2.type === "Feature" ? feature2.properties : {};
-    let coords = geom.coordinates;
-    switch (type) {
-      case "LineString":
-      case "MultiLineString": {
-        const lines = [];
-        if (type === "LineString") {
-          coords = [coords];
-        }
-        coords.forEach((line) => {
-          lineclip(line, bbox2, lines);
-        });
-        if (lines.length === 1) {
-          return lineString(lines[0], properties);
-        }
-        return multiLineString(lines, properties);
-      }
-      case "Polygon":
-        return polygon(clipPolygon(coords, bbox2), properties);
-      case "MultiPolygon":
-        return multiPolygon(
-          coords.map((poly) => {
-            return clipPolygon(poly, bbox2);
-          }),
-          properties
-        );
-      default:
-        throw new Error("geometry " + type + " not supported");
-    }
-  }
-  function clipPolygon(rings, bbox2) {
-    const outRings = [];
-    for (const ring of rings) {
-      const clipped = polygonclip(ring, bbox2);
-      if (clipped.length > 0) {
-        if (clipped[0][0] !== clipped[clipped.length - 1][0] || clipped[0][1] !== clipped[clipped.length - 1][1]) {
-          clipped.push(clipped[0]);
-        }
-        if (clipped.length >= 4) {
-          outRings.push(clipped);
-        }
-      }
-    }
-    return outRings;
-  }
-  var turf_bbox_clip_default = bboxClip;
-
   // node_modules/h3-js/dist/h3-js.es.js
   var libh3 = function(libh32) {
     libh32 = libh32 || {};
@@ -19587,122 +19177,575 @@
     tempStr = topNum + tempStr.substring(1);
     return tempStr;
   }
-  function splitLongToH3Index(lower, upper) {
-    return hexFrom32Bit(upper) + zeroPad(8, hexFrom32Bit(lower));
+  function splitLongToH3Index(lower, upper) {
+    return hexFrom32Bit(upper) + zeroPad(8, hexFrom32Bit(lower));
+  }
+  function zeroPad(fullLen, numStr) {
+    var numZeroes = fullLen - numStr.length;
+    var outStr = "";
+    for (var i = 0; i < numZeroes; i++) {
+      outStr += "0";
+    }
+    outStr = outStr + numStr;
+    return outStr;
+  }
+  var UPPER_BIT_DIVISOR = Math.pow(2, 32);
+  function polygonArrayToGeoLoop(polygonArray, geoLoop, isGeoJson) {
+    var numVerts = polygonArray.length;
+    var geoCoordArray = libh3._calloc(numVerts, SZ_LATLNG);
+    var latIndex = isGeoJson ? 1 : 0;
+    var lngIndex = isGeoJson ? 0 : 1;
+    for (var i = 0; i < numVerts * 2; i += 2) {
+      libh3.HEAPF64.set([polygonArray[i / 2][latIndex], polygonArray[i / 2][lngIndex]].map(degsToRads), geoCoordArray / SZ_DBL + i);
+    }
+    libh3.HEAPU32.set([numVerts, geoCoordArray], geoLoop / SZ_INT);
+    return geoLoop;
+  }
+  function coordinatesToGeoPolygon(coordinates, isGeoJson) {
+    var numHoles = coordinates.length - 1;
+    var geoPolygon = libh3._calloc(SZ_GEOPOLYGON);
+    var geoLoopOffset = 0;
+    var numHolesOffset = geoLoopOffset + SZ_GEOLOOP;
+    var holesOffset = numHolesOffset + SZ_INT;
+    polygonArrayToGeoLoop(coordinates[0], geoPolygon + geoLoopOffset, isGeoJson);
+    var holes;
+    if (numHoles > 0) {
+      holes = libh3._calloc(numHoles, SZ_GEOLOOP);
+      for (var i = 0; i < numHoles; i++) {
+        polygonArrayToGeoLoop(coordinates[i + 1], holes + SZ_GEOLOOP * i, isGeoJson);
+      }
+    }
+    libh3.setValue(geoPolygon + numHolesOffset, numHoles, "i32");
+    libh3.setValue(geoPolygon + holesOffset, holes, "i32");
+    return geoPolygon;
+  }
+  function destroyGeoPolygon(geoPolygon) {
+    var geoLoopOffset = 0;
+    var numHolesOffset = geoLoopOffset + SZ_GEOLOOP;
+    var holesOffset = numHolesOffset + SZ_INT;
+    var geoLoopArrayOffset = SZ_INT;
+    libh3._free(libh3.getValue(geoPolygon + geoLoopOffset + geoLoopArrayOffset, "i8*"));
+    var numHoles = libh3.getValue(geoPolygon + numHolesOffset, "i32");
+    if (numHoles > 0) {
+      var holes = libh3.getValue(geoPolygon + holesOffset, "i32");
+      for (var i = 0; i < numHoles; i++) {
+        libh3._free(libh3.getValue(holes + SZ_GEOLOOP * i + geoLoopArrayOffset, "i8*"));
+      }
+      libh3._free(holes);
+    }
+    libh3._free(geoPolygon);
+  }
+  function readH3IndexFromPointer(cAddress, offset) {
+    if (offset === void 0) offset = 0;
+    var lower = libh3.getValue(cAddress + SZ_H3INDEX * offset, "i32");
+    var upper = libh3.getValue(cAddress + SZ_H3INDEX * offset + SZ_INT, "i32");
+    return upper ? splitLongToH3Index(lower, upper) : null;
+  }
+  function readInt64AsDoubleFromPointer(cAddress) {
+    return H3.readInt64AsDoubleFromPointer(cAddress);
+  }
+  function readArrayOfH3Indexes(cAddress, maxCount) {
+    var out = [];
+    for (var i = 0; i < maxCount; i++) {
+      var h3Index = readH3IndexFromPointer(cAddress, i);
+      if (h3Index !== null) {
+        out.push(h3Index);
+      }
+    }
+    return out;
+  }
+  function getResolution2(h3Index) {
+    var ref = h3IndexToSplitLong(h3Index);
+    var lower = ref[0];
+    var upper = ref[1];
+    if (!H3.isValidCell(lower, upper)) {
+      return -1;
+    }
+    return H3.getResolution(lower, upper);
+  }
+  function polygonToCells(coordinates, res, isGeoJson) {
+    validateRes(res);
+    isGeoJson = Boolean(isGeoJson);
+    if (coordinates.length === 0 || coordinates[0].length === 0) {
+      return [];
+    }
+    var polygon2 = typeof coordinates[0][0] === "number" ? [coordinates] : coordinates;
+    var geoPolygon = coordinatesToGeoPolygon(
+      // @ts-expect-error - There's no way to convince TS that polygon is now number[][][]
+      polygon2,
+      isGeoJson
+    );
+    var countPtr = libh3._malloc(SZ_INT64);
+    try {
+      throwIfError(H3.maxPolygonToCellsSize(geoPolygon, res, 0, countPtr));
+      var count = validateArrayLength(readInt64AsDoubleFromPointer(countPtr));
+      var hexagons = libh3._calloc(count, SZ_H3INDEX);
+      try {
+        throwIfError(H3.polygonToCells(geoPolygon, res, 0, hexagons));
+        return readArrayOfH3Indexes(hexagons, count);
+      } finally {
+        libh3._free(hexagons);
+      }
+    } finally {
+      libh3._free(countPtr);
+      destroyGeoPolygon(geoPolygon);
+    }
+  }
+  function degsToRads(deg) {
+    return deg * Math.PI / 180;
+  }
+
+  // node_modules/@turf/bbox-clip/dist/esm/index.js
+  function lineclip(points, bbox2, result) {
+    var len = points.length, codeA = bitCode(points[0], bbox2), part = [], i, codeB, lastCode;
+    let a;
+    let b;
+    if (!result) result = [];
+    for (i = 1; i < len; i++) {
+      a = points[i - 1];
+      b = points[i];
+      codeB = lastCode = bitCode(b, bbox2);
+      while (true) {
+        if (!(codeA | codeB)) {
+          part.push(a);
+          if (codeB !== lastCode) {
+            part.push(b);
+            if (i < len - 1) {
+              result.push(part);
+              part = [];
+            }
+          } else if (i === len - 1) {
+            part.push(b);
+          }
+          break;
+        } else if (codeA & codeB) {
+          break;
+        } else if (codeA) {
+          a = intersect2(a, b, codeA, bbox2);
+          codeA = bitCode(a, bbox2);
+        } else {
+          b = intersect2(a, b, codeB, bbox2);
+          codeB = bitCode(b, bbox2);
+        }
+      }
+      codeA = lastCode;
+    }
+    if (part.length) result.push(part);
+    return result;
+  }
+  function polygonclip(points, bbox2) {
+    var result, edge, prev, prevInside, i, p, inside;
+    for (edge = 1; edge <= 8; edge *= 2) {
+      result = [];
+      prev = points[points.length - 1];
+      prevInside = !(bitCode(prev, bbox2) & edge);
+      for (i = 0; i < points.length; i++) {
+        p = points[i];
+        inside = !(bitCode(p, bbox2) & edge);
+        if (inside !== prevInside) result.push(intersect2(prev, p, edge, bbox2));
+        if (inside) result.push(p);
+        prev = p;
+        prevInside = inside;
+      }
+      points = result;
+      if (!points.length) break;
+    }
+    return result;
+  }
+  function intersect2(a, b, edge, bbox2) {
+    return edge & 8 ? [a[0] + (b[0] - a[0]) * (bbox2[3] - a[1]) / (b[1] - a[1]), bbox2[3]] : edge & 4 ? [a[0] + (b[0] - a[0]) * (bbox2[1] - a[1]) / (b[1] - a[1]), bbox2[1]] : edge & 2 ? [bbox2[2], a[1] + (b[1] - a[1]) * (bbox2[2] - a[0]) / (b[0] - a[0])] : edge & 1 ? [bbox2[0], a[1] + (b[1] - a[1]) * (bbox2[0] - a[0]) / (b[0] - a[0])] : null;
+  }
+  function bitCode(p, bbox2) {
+    var code = 0;
+    if (p[0] < bbox2[0]) code |= 1;
+    else if (p[0] > bbox2[2]) code |= 2;
+    if (p[1] < bbox2[1]) code |= 4;
+    else if (p[1] > bbox2[3]) code |= 8;
+    return code;
+  }
+  function bboxClip(feature2, bbox2) {
+    const geom = getGeom(feature2);
+    const type = geom.type;
+    const properties = feature2.type === "Feature" ? feature2.properties : {};
+    let coords = geom.coordinates;
+    switch (type) {
+      case "LineString":
+      case "MultiLineString": {
+        const lines = [];
+        if (type === "LineString") {
+          coords = [coords];
+        }
+        coords.forEach((line) => {
+          lineclip(line, bbox2, lines);
+        });
+        if (lines.length === 1) {
+          return lineString(lines[0], properties);
+        }
+        return multiLineString(lines, properties);
+      }
+      case "Polygon":
+        return polygon(clipPolygon(coords, bbox2), properties);
+      case "MultiPolygon":
+        return multiPolygon(
+          coords.map((poly) => {
+            return clipPolygon(poly, bbox2);
+          }),
+          properties
+        );
+      default:
+        throw new Error("geometry " + type + " not supported");
+    }
+  }
+  function clipPolygon(rings, bbox2) {
+    const outRings = [];
+    for (const ring of rings) {
+      const clipped = polygonclip(ring, bbox2);
+      if (clipped.length > 0) {
+        if (clipped[0][0] !== clipped[clipped.length - 1][0] || clipped[0][1] !== clipped[clipped.length - 1][1]) {
+          clipped.push(clipped[0]);
+        }
+        if (clipped.length >= 4) {
+          outRings.push(clipped);
+        }
+      }
+    }
+    return outRings;
+  }
+  var turf_bbox_clip_default = bboxClip;
+
+  // src/filters/tileIntersection.ts
+  function intersectTileGeometry(tileBbox, tileFormat, spatialFilter) {
+    const tilePolygon = turf_bbox_polygon_default(tileBbox);
+    if (!spatialFilter || turf_boolean_within_default(tilePolygon, spatialFilter)) {
+      return true;
+    }
+    const clippedSpatialFilter = turf_intersect_default(
+      featureCollection([tilePolygon, feature(spatialFilter)])
+    );
+    if (!clippedSpatialFilter) {
+      return false;
+    }
+    return tileFormat === "mvt" /* MVT */ ? transformToTileCoords(clippedSpatialFilter.geometry, tileBbox) : clippedSpatialFilter.geometry;
+  }
+  function intersectTileRaster(parent, cellResolution, spatialFilter) {
+    return intersectTileQuadbin(parent, cellResolution, spatialFilter);
+  }
+  function intersectTileQuadbin(parent, cellResolution, spatialFilter) {
+    const tilePolygon = cellToBoundary(parent);
+    if (!spatialFilter || turf_boolean_within_default(tilePolygon, spatialFilter)) {
+      return true;
+    }
+    const clippedSpatialFilter = turf_intersect_default(
+      featureCollection([feature(tilePolygon), feature(spatialFilter)])
+    );
+    if (!clippedSpatialFilter) {
+      return false;
+    }
+    const cells = geometryToCells(
+      clippedSpatialFilter.geometry,
+      cellResolution
+    );
+    return new Set(cells);
+  }
+  var BBOX_WEST = [-180, -90, 0, 90];
+  var BBOX_EAST = [0, -90, 180, 90];
+  function intersectTileH3(cellResolution, spatialFilter) {
+    if (!spatialFilter) {
+      return true;
+    }
+    const spatialFilterFeature = feature(spatialFilter);
+    const cellsWest = polygonToCells(
+      turf_bbox_clip_default(spatialFilterFeature, BBOX_WEST).geometry.coordinates,
+      cellResolution,
+      true
+    );
+    const cellsEast = polygonToCells(
+      turf_bbox_clip_default(spatialFilterFeature, BBOX_EAST).geometry.coordinates,
+      cellResolution,
+      true
+    );
+    return new Set(cellsWest.concat(cellsEast));
+  }
+
+  // src/filters/tileFeaturesGeometries.ts
+  var FEATURE_GEOM_PROPERTY = "__geomValue";
+  function tileFeaturesGeometries({
+    tiles: tiles2,
+    tileFormat,
+    spatialFilter,
+    uniqueIdProperty,
+    options
+  }) {
+    const map = /* @__PURE__ */ new Map();
+    for (const tile of tiles2) {
+      if (tile.isVisible === false || !tile.data) {
+        continue;
+      }
+      const tileBbox = [
+        tile.bbox.west,
+        tile.bbox.south,
+        tile.bbox.east,
+        tile.bbox.north
+      ];
+      const intersection3 = intersectTileGeometry(
+        tileBbox,
+        tileFormat,
+        spatialFilter
+      );
+      if (intersection3 === false) continue;
+      const transformedSpatialFilter = intersection3 === true ? void 0 : intersection3;
+      calculateFeatures({
+        map,
+        spatialFilter: transformedSpatialFilter,
+        data: tile.data.points,
+        type: "Point",
+        bbox: tileBbox,
+        tileFormat,
+        uniqueIdProperty,
+        options
+      });
+      calculateFeatures({
+        map,
+        spatialFilter: transformedSpatialFilter,
+        data: tile.data.lines,
+        type: "LineString",
+        bbox: tileBbox,
+        tileFormat,
+        uniqueIdProperty,
+        options
+      });
+      calculateFeatures({
+        map,
+        spatialFilter: transformedSpatialFilter,
+        data: tile.data.polygons,
+        type: "Polygon",
+        bbox: tileBbox,
+        tileFormat,
+        uniqueIdProperty,
+        options
+      });
+    }
+    return Array.from(map.values());
+  }
+  function processTileFeatureProperties({
+    map,
+    data,
+    startIndex,
+    endIndex,
+    type,
+    bbox: bbox2,
+    tileFormat,
+    uniqueIdProperty,
+    storeGeometry,
+    spatialFilter
+  }) {
+    const tileProps = getPropertiesFromTile(data, startIndex);
+    const uniquePropertyValue = getUniquePropertyValue(
+      tileProps,
+      uniqueIdProperty,
+      map
+    );
+    if (!uniquePropertyValue || map.has(uniquePropertyValue)) {
+      return;
+    }
+    let geometry = null;
+    if (storeGeometry || spatialFilter) {
+      const { positions } = data;
+      const ringCoordinates = getRingCoordinatesFor(
+        startIndex,
+        endIndex,
+        positions
+      );
+      geometry = getFeatureByType(ringCoordinates, type);
+    }
+    if (geometry && spatialFilter && !turf_boolean_intersects_default(geometry, spatialFilter)) {
+      return;
+    }
+    const properties = parseProperties(tileProps);
+    if (storeGeometry && geometry) {
+      properties[FEATURE_GEOM_PROPERTY] = tileFormat === "mvt" /* MVT */ ? transformTileCoordsToWGS84(geometry, bbox2) : geometry;
+    }
+    map.set(uniquePropertyValue, properties);
+  }
+  function addIntersectedFeaturesInTile({
+    map,
+    data,
+    spatialFilter,
+    type,
+    bbox: bbox2,
+    tileFormat,
+    uniqueIdProperty,
+    options
+  }) {
+    const indices = getIndices(data, type);
+    const storeGeometry = options?.storeGeometry || false;
+    for (let i = 0; i < indices.length - 1; i++) {
+      const startIndex = indices[i];
+      const endIndex = indices[i + 1];
+      processTileFeatureProperties({
+        map,
+        data,
+        startIndex,
+        endIndex,
+        type,
+        bbox: bbox2,
+        tileFormat,
+        uniqueIdProperty,
+        storeGeometry,
+        spatialFilter
+      });
+    }
+  }
+  function getIndices(data, type) {
+    let indices;
+    switch (type) {
+      case "Polygon":
+        indices = data.primitivePolygonIndices;
+        break;
+      case "LineString":
+        indices = data.pathIndices;
+        break;
+      case "Point":
+        indices = createIndicesForPoints(data);
+        break;
+      default:
+        throw new Error(
+          `Unsupported geometry type: ${type}`
+        );
+    }
+    return indices.value;
+  }
+  function getFeatureId(data, startIndex) {
+    return data.featureIds.value[startIndex];
   }
-  function zeroPad(fullLen, numStr) {
-    var numZeroes = fullLen - numStr.length;
-    var outStr = "";
-    for (var i = 0; i < numZeroes; i++) {
-      outStr += "0";
+  function getPropertiesFromTile(data, startIndex) {
+    const featureId2 = getFeatureId(data, startIndex);
+    const { properties, numericProps, fields } = data;
+    const result = {
+      uniqueId: fields?.[featureId2]?.id,
+      properties: properties[featureId2],
+      numericProps: {}
+    };
+    for (const key in numericProps) {
+      result.numericProps[key] = numericProps[key].value[startIndex];
     }
-    outStr = outStr + numStr;
-    return outStr;
+    return result;
   }
-  var UPPER_BIT_DIVISOR = Math.pow(2, 32);
-  function polygonArrayToGeoLoop(polygonArray, geoLoop, isGeoJson) {
-    var numVerts = polygonArray.length;
-    var geoCoordArray = libh3._calloc(numVerts, SZ_LATLNG);
-    var latIndex = isGeoJson ? 1 : 0;
-    var lngIndex = isGeoJson ? 0 : 1;
-    for (var i = 0; i < numVerts * 2; i += 2) {
-      libh3.HEAPF64.set([polygonArray[i / 2][latIndex], polygonArray[i / 2][lngIndex]].map(degsToRads), geoCoordArray / SZ_DBL + i);
-    }
-    libh3.HEAPU32.set([numVerts, geoCoordArray], geoLoop / SZ_INT);
-    return geoLoop;
+  function parseProperties(tileProps) {
+    const { properties, numericProps } = tileProps;
+    return Object.assign({}, properties, numericProps);
   }
-  function coordinatesToGeoPolygon(coordinates, isGeoJson) {
-    var numHoles = coordinates.length - 1;
-    var geoPolygon = libh3._calloc(SZ_GEOPOLYGON);
-    var geoLoopOffset = 0;
-    var numHolesOffset = geoLoopOffset + SZ_GEOLOOP;
-    var holesOffset = numHolesOffset + SZ_INT;
-    polygonArrayToGeoLoop(coordinates[0], geoPolygon + geoLoopOffset, isGeoJson);
-    var holes;
-    if (numHoles > 0) {
-      holes = libh3._calloc(numHoles, SZ_GEOLOOP);
-      for (var i = 0; i < numHoles; i++) {
-        polygonArrayToGeoLoop(coordinates[i + 1], holes + SZ_GEOLOOP * i, isGeoJson);
-      }
+  function getUniquePropertyValue(tileProps, uniqueIdProperty, map) {
+    if (uniqueIdProperty) {
+      return getValueFromTileProps(tileProps, uniqueIdProperty);
     }
-    libh3.setValue(geoPolygon + numHolesOffset, numHoles, "i32");
-    libh3.setValue(geoPolygon + holesOffset, holes, "i32");
-    return geoPolygon;
-  }
-  function destroyGeoPolygon(geoPolygon) {
-    var geoLoopOffset = 0;
-    var numHolesOffset = geoLoopOffset + SZ_GEOLOOP;
-    var holesOffset = numHolesOffset + SZ_INT;
-    var geoLoopArrayOffset = SZ_INT;
-    libh3._free(libh3.getValue(geoPolygon + geoLoopOffset + geoLoopArrayOffset, "i8*"));
-    var numHoles = libh3.getValue(geoPolygon + numHolesOffset, "i32");
-    if (numHoles > 0) {
-      var holes = libh3.getValue(geoPolygon + holesOffset, "i32");
-      for (var i = 0; i < numHoles; i++) {
-        libh3._free(libh3.getValue(holes + SZ_GEOLOOP * i + geoLoopArrayOffset, "i8*"));
-      }
-      libh3._free(holes);
+    if (tileProps.uniqueId) {
+      return tileProps.uniqueId;
     }
-    libh3._free(geoPolygon);
-  }
-  function readH3IndexFromPointer(cAddress, offset) {
-    if (offset === void 0) offset = 0;
-    var lower = libh3.getValue(cAddress + SZ_H3INDEX * offset, "i32");
-    var upper = libh3.getValue(cAddress + SZ_H3INDEX * offset + SZ_INT, "i32");
-    return upper ? splitLongToH3Index(lower, upper) : null;
+    const artificialId = map.size + 1;
+    return getValueFromTileProps(tileProps, "cartodb_id") || getValueFromTileProps(tileProps, "geoid") || artificialId;
   }
-  function readInt64AsDoubleFromPointer(cAddress) {
-    return H3.readInt64AsDoubleFromPointer(cAddress);
+  function getValueFromTileProps(tileProps, propertyName) {
+    const { properties, numericProps } = tileProps;
+    return numericProps[propertyName] || properties[propertyName];
   }
-  function readArrayOfH3Indexes(cAddress, maxCount) {
-    var out = [];
-    for (var i = 0; i < maxCount; i++) {
-      var h3Index = readH3IndexFromPointer(cAddress, i);
-      if (h3Index !== null) {
-        out.push(h3Index);
-      }
+  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 out;
   }
-  function getResolution2(h3Index) {
-    var ref = h3IndexToSplitLong(h3Index);
-    var lower = ref[0];
-    var upper = ref[1];
-    if (!H3.isValidCell(lower, upper)) {
-      return -1;
+  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 H3.getResolution(lower, upper);
+    return ringCoordinates;
   }
-  function polygonToCells(coordinates, res, isGeoJson) {
-    validateRes(res);
-    isGeoJson = Boolean(isGeoJson);
-    if (coordinates.length === 0 || coordinates[0].length === 0) {
-      return [];
+  function calculateFeatures({
+    map,
+    spatialFilter,
+    data,
+    type,
+    bbox: bbox2,
+    tileFormat,
+    uniqueIdProperty,
+    options
+  }) {
+    if (!data?.properties.length) {
+      return;
     }
-    var polygon2 = typeof coordinates[0][0] === "number" ? [coordinates] : coordinates;
-    var geoPolygon = coordinatesToGeoPolygon(
-      // @ts-expect-error - There's no way to convince TS that polygon is now number[][][]
-      polygon2,
-      isGeoJson
-    );
-    var countPtr = libh3._malloc(SZ_INT64);
-    try {
-      throwIfError(H3.maxPolygonToCellsSize(geoPolygon, res, 0, countPtr));
-      var count = validateArrayLength(readInt64AsDoubleFromPointer(countPtr));
-      var hexagons = libh3._calloc(count, SZ_H3INDEX);
-      try {
-        throwIfError(H3.polygonToCells(geoPolygon, res, 0, hexagons));
-        return readArrayOfH3Indexes(hexagons, count);
-      } finally {
-        libh3._free(hexagons);
-      }
-    } finally {
-      libh3._free(countPtr);
-      destroyGeoPolygon(geoPolygon);
+    if (!spatialFilter) {
+      addAllFeaturesInTile({
+        map,
+        data,
+        type,
+        bbox: bbox2,
+        tileFormat,
+        uniqueIdProperty,
+        options
+      });
+    } else {
+      addIntersectedFeaturesInTile({
+        map,
+        data,
+        spatialFilter,
+        type,
+        bbox: bbox2,
+        tileFormat,
+        uniqueIdProperty,
+        options
+      });
     }
   }
-  function degsToRads(deg) {
-    return deg * Math.PI / 180;
+  function addAllFeaturesInTile({
+    map,
+    data,
+    type,
+    bbox: bbox2,
+    tileFormat,
+    uniqueIdProperty,
+    options
+  }) {
+    const indices = getIndices(data, type);
+    const storeGeometry = options?.storeGeometry || false;
+    for (let i = 0; i < indices.length - 1; i++) {
+      const startIndex = indices[i];
+      const endIndex = indices[i + 1];
+      processTileFeatureProperties({
+        map,
+        data,
+        startIndex,
+        endIndex,
+        type,
+        bbox: bbox2,
+        tileFormat,
+        uniqueIdProperty,
+        storeGeometry
+      });
+    }
+  }
+  function createIndicesForPoints(data) {
+    const featureIds = data.featureIds.value;
+    const lastFeatureId = featureIds[featureIds.length - 1];
+    const PointIndicesArray = featureIds.constructor;
+    const pointIndices = {
+      value: new PointIndicesArray(featureIds.length + 1),
+      size: 1
+    };
+    pointIndices.value.set(featureIds);
+    pointIndices.value.set([lastFeatureId + 1], featureIds.length);
+    return pointIndices;
   }
 
   // src/filters/tileFeaturesSpatialIndex.ts
@@ -19714,28 +19757,42 @@
   }) {
     const map = /* @__PURE__ */ new Map();
     const spatialIndex = getSpatialIndex(spatialDataType);
-    const resolution = getResolution3(tiles2, spatialIndex);
+    const cellResolution = getResolution3(tiles2, spatialIndex);
     const spatialIndexIDName = spatialDataColumn ? spatialDataColumn : spatialIndex;
-    if (!resolution) {
+    if (!cellResolution) {
       return [];
     }
-    const cells = getCellsCoverGeometry(spatialFilter, spatialIndex, resolution);
-    if (!cells?.length) {
-      return [];
+    let intersection3;
+    if (spatialIndex === "h3" /* H3 */) {
+      intersection3 = intersectTileH3(cellResolution, spatialFilter);
     }
-    const cellsSet = new Set(cells);
     for (const tile of tiles2) {
       if (tile.isVisible === false || !tile.data) {
         continue;
       }
+      if (spatialIndex === "quadbin" /* QUADBIN */) {
+        const parent = getTileIndex(tile, spatialIndex);
+        intersection3 = intersectTileQuadbin(
+          parent,
+          cellResolution,
+          spatialFilter
+        );
+      }
+      if (!intersection3) continue;
       tile.data.forEach((d) => {
-        if (cellsSet.has(d.id)) {
+        if (intersection3 === true || intersection3.has(d.id)) {
           map.set(d.id, { ...d.properties, [spatialIndexIDName]: d.id });
         }
       });
     }
     return Array.from(map.values());
   }
+  function getTileIndex(tile, spatialIndex) {
+    if (spatialIndex === "quadbin" /* QUADBIN */) {
+      return tile.index.q;
+    }
+    return tile.id;
+  }
   function getResolution3(tiles2, spatialIndex) {
     const data = tiles2.find((tile) => tile.data?.length)?.data;
     if (!data) {
@@ -19748,26 +19805,6 @@
       return getResolution2(data[0].id);
     }
   }
-  var bboxWest = [-180, -90, 0, 90];
-  var bboxEast = [0, -90, 180, 90];
-  function getCellsCoverGeometry(geometry, spatialIndex, resolution) {
-    if (spatialIndex === "quadbin" /* QUADBIN */) {
-      return geometryToCells(geometry, resolution);
-    }
-    if (spatialIndex === "h3" /* H3 */) {
-      return polygonToCells(
-        turf_bbox_clip_default(geometry, bboxWest).geometry.coordinates,
-        resolution,
-        true
-      ).concat(
-        polygonToCells(
-          turf_bbox_clip_default(geometry, bboxEast).geometry.coordinates,
-          resolution,
-          true
-        )
-      );
-    }
-  }
   function getSpatialIndex(spatialDataType) {
     switch (spatialDataType) {
       case "h3":
@@ -19801,15 +19838,15 @@
     const data = /* @__PURE__ */ new Map();
     for (const tile of tiles2) {
       const parent = tile.index.q;
-      const tilePolygon = cellToBoundary(parent);
-      const tileFilter = turf_intersect_default(
-        featureCollection([feature(tilePolygon), feature(options.spatialFilter)])
+      const intersection3 = intersectTileRaster(
+        parent,
+        cellResolution,
+        options.spatialFilter
       );
-      const needsFilter = tileFilter ? !turf_boolean_within_default(tilePolygon, options.spatialFilter) : false;
-      const tileFilterCells = needsFilter ? new Set(geometryToCells(tileFilter.geometry, cellResolution)) : null;
+      if (intersection3 === false) continue;
       const tileSortedCells = cellToChildrenSorted(parent, cellResolution);
       for (let i = 0; i < tileSortedCells.length; i++) {
-        if (needsFilter && !tileFilterCells.has(tileSortedCells[i])) {
+        if (intersection3 !== true && !intersection3.has(tileSortedCells[i])) {
           continue;
         }
         const cellData = {};
@@ -20044,16 +20081,21 @@
     });
   }
 
+  // src/widget-sources/constants.ts
+  var OTHERS_CATEGORY_NAME = "_carto_others";
+
   // src/operations/groupBy.ts
   function groupValuesByColumn({
     data,
     valuesColumns,
     joinOperation,
     keysColumn,
-    operation: operation2
+    operation: operation2,
+    othersThreshold,
+    orderBy = "frequency_desc"
   }) {
     if (Array.isArray(data) && data.length === 0) {
-      return null;
+      return { rows: null };
     }
     const groups = data.reduce((accumulator, item) => {
       const group = item[keysColumn];
@@ -20068,13 +20110,44 @@
       return accumulator;
     }, /* @__PURE__ */ new Map());
     const targetOperation = aggregationFunctions[operation2];
-    if (targetOperation) {
-      return Array.from(groups).map(([name, value]) => ({
-        name,
-        value: targetOperation(value)
-      }));
+    if (!targetOperation) {
+      return { rows: [] };
+    }
+    const allCategories = Array.from(groups).map(([name, value]) => ({
+      name,
+      value: targetOperation(value)
+    })).sort(getSorter(orderBy));
+    if (othersThreshold && allCategories.length > othersThreshold) {
+      const otherValue = allCategories.slice(othersThreshold).flatMap(({ name }) => groups.get(name));
+      allCategories.push({
+        name: OTHERS_CATEGORY_NAME,
+        value: targetOperation(otherValue)
+      });
+      return {
+        rows: allCategories,
+        metadata: {
+          others: targetOperation(otherValue)
+        }
+      };
+    }
+    return {
+      rows: allCategories
+    };
+  }
+  function getSorter(orderBy) {
+    switch (orderBy) {
+      case "frequency_asc":
+        return (a, b) => a.value - b.value || localeCompare(a.name, b.name);
+      case "frequency_desc":
+        return (a, b) => b.value - a.value || localeCompare(a.name, b.name);
+      case "alphabetical_asc":
+        return (a, b) => localeCompare(a.name, b.name) || b.value - a.value;
+      case "alphabetical_desc":
+        return (a, b) => localeCompare(b.name, a.name) || b.value - a.value;
     }
-    return [];
+  }
+  function localeCompare(a, b) {
+    return (a ?? "null").localeCompare(b ?? "null");
   }
 
   // src/utils/dateUtils.ts
@@ -20604,7 +20677,7 @@
     }
     _extractTileFeatures(spatialFilter) {
       const prevInputs = this._tileFeatureExtractPreviousInputs;
-      if (this._features.length && prevInputs.spatialFilter && booleanEqual(prevInputs.spatialFilter, spatialFilter)) {
+      if (this._features.length && spatialFilterEquals(prevInputs.spatialFilter, spatialFilter)) {
         return;
       }
       this._features = tileFeatures({
@@ -20693,7 +20766,10 @@
       joinOperation,
       filters,
       filterOwner,
-      spatialFilter
+      spatialFilter,
+      othersThreshold,
+      orderBy = "frequency_desc",
+      rawResult
     }) {
       const filteredFeatures = this._getFilteredFeatures(
         spatialFilter,
@@ -20704,14 +20780,25 @@
         return [];
       }
       assertColumn(this._features, column, operationColumn);
-      const groups = groupValuesByColumn({
+      const result = groupValuesByColumn({
         data: filteredFeatures,
         valuesColumns: normalizeColumns(operationColumn || column),
         joinOperation,
         keysColumn: column,
-        operation: operation2
+        operation: operation2,
+        othersThreshold,
+        orderBy
       });
-      return groups || [];
+      if (rawResult) {
+        return result;
+      }
+      if (!othersThreshold) {
+        return result?.rows || [];
+      }
+      return [
+        ...result?.rows || [],
+        { name: OTHERS_CATEGORY_NAME, value: result?.metadata?.others }
+      ];
     }
     async getScatter({
       xAxisColumn,
@@ -20844,7 +20931,6 @@
      * INTERNAL
      */
     _getFilteredFeatures(spatialFilter, filters, filterOwner) {
-      assert(spatialFilter, "spatialFilter required for tilesets");
       this._extractTileFeatures(spatialFilter);
       return applyFilters(
         this._features,
@@ -20868,6 +20954,11 @@
   function normalizeColumns(columns) {
     return Array.isArray(columns) ? columns : typeof columns === "string" ? [columns] : [];
   }
+  function spatialFilterEquals(a, b) {
+    if (a === b) return true;
+    if (!a || !b) return false;
+    return booleanEqual(a, b);
+  }
 
   // src/workers/widget-tileset-worker.ts
   var source;