@carto/api-client 0.5.7-alpha.5 → 0.5.7

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;
@@ -5452,8 +5160,8 @@
     }
     if (ring && y === ring[0][1]) ring.pop();
   }
-  function appendHashTiles(hash2, tiles2) {
-    var keys = Object.keys(hash2);
+  function appendHashTiles(hash, tiles2) {
+    var keys = Object.keys(hash);
     for (var i = 0; i < keys.length; i++) {
       tiles2.push(fromID(+keys[i]));
     }
@@ -5468,6 +5176,26 @@
   }
   var B2 = [0x5555555555555555n, 0x3333333333333333n, 0x0f0f0f0f0f0f0f0fn, 0x00ff00ff00ff00ffn, 0x0000ffff0000ffffn, 0x00000000ffffffffn];
   var S = [0n, 1n, 2n, 4n, 8n, 16n];
+  var TILE_SIZE2 = 512;
+  function cellToOffset(quadbin) {
+    const {
+      x,
+      y,
+      z
+    } = cellToTile(quadbin);
+    const scale2 = TILE_SIZE2 / (1 << z);
+    return [x * scale2, TILE_SIZE2 - y * scale2, scale2];
+  }
+  function cellToWorldBounds(quadbin, coverage) {
+    const [xOffset, yOffset, scale2] = cellToOffset(quadbin);
+    return [[xOffset, yOffset], [xOffset + coverage * scale2, yOffset - coverage * scale2]];
+  }
+  function getCellPolygon(quadbin, coverage = 1) {
+    const [topLeft, bottomRight] = cellToWorldBounds(quadbin, coverage);
+    const [w, n] = worldToLngLat(topLeft);
+    const [e, s] = worldToLngLat(bottomRight);
+    return [e, n, e, s, w, s, w, n, e, n];
+  }
   function tileToCell(tile) {
     if (tile.z < 0 || tile.z > 26) {
       throw new Error("Wrong zoom");
@@ -5540,125 +5268,15 @@
       z
     }));
   }
+  function cellToBoundary(cell) {
+    const bbox2 = getCellPolygon(cell);
+    const boundary = [[bbox2[0], bbox2[1]], [bbox2[2], bbox2[3]], [bbox2[4], bbox2[5]], [bbox2[6], bbox2[7]], [bbox2[0], bbox2[1]]];
+    return {
+      type: "Polygon",
+      coordinates: [boundary]
+    };
+  }
 
-  // node_modules/@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 || {};
@@ -19553,128 +19171,581 @@
     if (num >= 0) {
       return num.toString(BASE_16);
     }
-    num = num & 2147483647;
-    var tempStr = zeroPad(8, num.toString(BASE_16));
-    var topNum = (parseInt(tempStr[0], BASE_16) + 8).toString(BASE_16);
-    tempStr = topNum + tempStr.substring(1);
-    return tempStr;
+    num = num & 2147483647;
+    var tempStr = zeroPad(8, num.toString(BASE_16));
+    var topNum = (parseInt(tempStr[0], BASE_16) + 8).toString(BASE_16);
+    tempStr = topNum + tempStr.substring(1);
+    return tempStr;
+  }
+  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 splitLongToH3Index(lower, upper) {
-    return hexFrom32Bit(upper) + zeroPad(8, hexFrom32Bit(lower));
+  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
@@ -19686,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) {
@@ -19720,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":
@@ -19756,62 +19821,6 @@
   var DEFAULT_AGGREGATION_EXP_ALIAS = "__aggregationValue";
   var DEFAULT_AGGREGATION_EXP = `1 AS ${DEFAULT_AGGREGATION_EXP_ALIAS}`;
 
-  // src/utils/CellSet.ts
-  var EMPTY_U32 = 2 ** 32 - 1;
-  var CellSet = class {
-    constructor(cells) {
-      /** List of cells stored by the set. Stored by reference, without copying. */
-      __publicField(this, "cells");
-      /** DataView representing a single cell ID. Pre-allocated to reduce memory during queries. */
-      __publicField(this, "cellView", new DataView(new ArrayBuffer(8)));
-      /** Hash table, mapping a hash index (computed) to an index in the 'cells' array. */
-      __publicField(this, "hashTable");
-      this.cells = cells;
-      this.hashTable = new Uint32Array(hashBuckets(cells.length)).fill(EMPTY_U32);
-      for (let cellIndex = 0; cellIndex < cells.length; cellIndex++) {
-        this.hashTable[this.hashLookup(cells[cellIndex])] = cellIndex;
-      }
-    }
-    has(cell) {
-      const hashIndex = this.hashLookup(cell);
-      return this.hashTable[hashIndex] !== EMPTY_U32;
-    }
-    hashLookup(cell) {
-      this.cellView.setBigUint64(0, cell);
-      const hashval = hash(this.cellView);
-      const hashmod = this.hashTable.length - 1;
-      let bucket = hashval & hashmod;
-      for (let probe = 0; probe <= hashmod; probe++) {
-        const cellIndex = this.hashTable[bucket];
-        if (cellIndex === EMPTY_U32 || cell === this.cells[cellIndex]) {
-          return bucket;
-        }
-        bucket = bucket + probe + 1 & hashmod;
-      }
-      throw new Error("Hash table full.");
-    }
-  };
-  function hash(view, h = 0) {
-    const m = 1540483477;
-    const r = 24;
-    for (let i = 0, il = view.byteLength / 4; i < il; i++) {
-      let k = view.getUint32(i * 4);
-      k = Math.imul(k, m) >>> 0;
-      k = (k ^ k >> r) >>> 0;
-      k = Math.imul(k, m) >>> 0;
-      h = Math.imul(h, m) >>> 0;
-      h = (h ^ k) >>> 0;
-    }
-    return h;
-  }
-  function hashBuckets(initialCount) {
-    let buckets = 1;
-    while (buckets < initialCount + initialCount / 4) {
-      buckets *= 2;
-    }
-    return buckets;
-  }
-
   // src/filters/tileFeaturesRaster.ts
   function tileFeaturesRaster({
     tiles: tiles2,
@@ -19826,15 +19835,20 @@
     const tileResolution = getResolution(tiles2[0].index.q);
     const tileBlockSize = tiles2[0].data.blockSize;
     const cellResolution = tileResolution + BigInt(Math.log2(tileBlockSize));
-    const spatialFilterCells = new CellSet(
-      geometryToCells(options.spatialFilter, cellResolution)
-    );
     const data = /* @__PURE__ */ new Map();
     for (const tile of tiles2) {
       const parent = tile.index.q;
-      const children = cellToChildrenSorted(parent, cellResolution);
-      for (let i = 0; i < children.length; i++) {
-        if (!spatialFilterCells.has(children[i])) continue;
+      const intersection3 = intersectTileRaster(
+        parent,
+        cellResolution,
+        options.spatialFilter
+      );
+      if (intersection3 === false) continue;
+      const tileSortedCells = cellToChildrenSorted(parent, cellResolution);
+      for (let i = 0; i < tileSortedCells.length; i++) {
+        if (intersection3 !== true && !intersection3.has(tileSortedCells[i])) {
+          continue;
+        }
         const cellData = {};
         let cellDataExists = false;
         for (const band in tile.data.cells.numericProps) {
@@ -19846,7 +19860,7 @@
           }
         }
         if (cellDataExists) {
-          data.set(children[i], cellData);
+          data.set(tileSortedCells[i], cellData);
         }
       }
     }
@@ -20627,7 +20641,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({
@@ -20867,7 +20881,6 @@
      * INTERNAL
      */
     _getFilteredFeatures(spatialFilter, filters, filterOwner) {
-      assert(spatialFilter, "spatialFilter required for tilesets");
       this._extractTileFeatures(spatialFilter);
       return applyFilters(
         this._features,
@@ -20891,6 +20904,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;