@carto/api-client 0.5.0-alpha.7 → 0.5.0-alpha.9

package/build/chunk-LEI5PI5X.js

@@ -1,2063 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __commonJS = (cb, mod2) => function __require() {
-  return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
-  mod2
-));
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// node_modules/tilebelt/index.js
-var require_tilebelt = __commonJS({
-  "node_modules/tilebelt/index.js"(exports, module) {
-    "use strict";
-    var d2r = Math.PI / 180;
-    var r2d = 180 / Math.PI;
-    function tileToBBOX(tile) {
-      var e = tile2lon(tile[0] + 1, tile[2]);
-      var w = tile2lon(tile[0], tile[2]);
-      var s = tile2lat(tile[1] + 1, tile[2]);
-      var n = tile2lat(tile[1], tile[2]);
-      return [w, s, e, n];
-    }
-    function tileToGeoJSON(tile) {
-      var bbox = tileToBBOX(tile);
-      var poly = {
-        type: "Polygon",
-        coordinates: [
-          [
-            [bbox[0], bbox[1]],
-            [bbox[0], bbox[3]],
-            [bbox[2], bbox[3]],
-            [bbox[2], bbox[1]],
-            [bbox[0], bbox[1]]
-          ]
-        ]
-      };
-      return poly;
-    }
-    function tile2lon(x, z) {
-      return x / Math.pow(2, z) * 360 - 180;
-    }
-    function tile2lat(y, z) {
-      var n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);
-      return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
-    }
-    function pointToTile(lon, lat, z) {
-      var tile = pointToTileFraction(lon, lat, z);
-      tile[0] = Math.floor(tile[0]);
-      tile[1] = Math.floor(tile[1]);
-      return tile;
-    }
-    function getChildren(tile) {
-      return [
-        [tile[0] * 2, tile[1] * 2, tile[2] + 1],
-        [tile[0] * 2 + 1, tile[1] * 2, tile[2] + 1],
-        [tile[0] * 2 + 1, tile[1] * 2 + 1, tile[2] + 1],
-        [tile[0] * 2, tile[1] * 2 + 1, tile[2] + 1]
-      ];
-    }
-    function getParent(tile) {
-      if (tile[0] % 2 === 0 && tile[1] % 2 === 0) {
-        return [tile[0] / 2, tile[1] / 2, tile[2] - 1];
-      } else if (tile[0] % 2 === 0 && !tile[1] % 2 === 0) {
-        return [tile[0] / 2, (tile[1] - 1) / 2, tile[2] - 1];
-      } else if (!tile[0] % 2 === 0 && tile[1] % 2 === 0) {
-        return [(tile[0] - 1) / 2, tile[1] / 2, tile[2] - 1];
-      } else {
-        return [(tile[0] - 1) / 2, (tile[1] - 1) / 2, tile[2] - 1];
-      }
-    }
-    function getSiblings(tile) {
-      return getChildren(getParent(tile));
-    }
-    function hasSiblings(tile, tiles2) {
-      var siblings = getSiblings(tile);
-      for (var i = 0; i < siblings.length; i++) {
-        if (!hasTile(tiles2, siblings[i])) return false;
-      }
-      return true;
-    }
-    function hasTile(tiles2, tile) {
-      for (var i = 0; i < tiles2.length; i++) {
-        if (tilesEqual(tiles2[i], tile)) return true;
-      }
-      return false;
-    }
-    function tilesEqual(tile1, tile2) {
-      return tile1[0] === tile2[0] && tile1[1] === tile2[1] && tile1[2] === tile2[2];
-    }
-    function tileToQuadkey(tile) {
-      var index = "";
-      for (var z = tile[2]; z > 0; z--) {
-        var b = 0;
-        var mask = 1 << z - 1;
-        if ((tile[0] & mask) !== 0) b++;
-        if ((tile[1] & mask) !== 0) b += 2;
-        index += b.toString();
-      }
-      return index;
-    }
-    function quadkeyToTile(quadkey) {
-      var x = 0;
-      var y = 0;
-      var z = quadkey.length;
-      for (var i = z; i > 0; i--) {
-        var mask = 1 << i - 1;
-        switch (quadkey[z - i]) {
-          case "0":
-            break;
-          case "1":
-            x |= mask;
-            break;
-          case "2":
-            y |= mask;
-            break;
-          case "3":
-            x |= mask;
-            y |= mask;
-            break;
-        }
-      }
-      return [x, y, z];
-    }
-    function bboxToTile(bboxCoords) {
-      var min2 = pointToTile(bboxCoords[0], bboxCoords[1], 32);
-      var max2 = pointToTile(bboxCoords[2], bboxCoords[3], 32);
-      var bbox = [min2[0], min2[1], max2[0], max2[1]];
-      var z = getBboxZoom(bbox);
-      if (z === 0) return [0, 0, 0];
-      var x = bbox[0] >>> 32 - z;
-      var y = bbox[1] >>> 32 - z;
-      return [x, y, z];
-    }
-    function getBboxZoom(bbox) {
-      var MAX_ZOOM = 28;
-      for (var z = 0; z < MAX_ZOOM; z++) {
-        var mask = 1 << 32 - (z + 1);
-        if ((bbox[0] & mask) != (bbox[2] & mask) || (bbox[1] & mask) != (bbox[3] & mask)) {
-          return z;
-        }
-      }
-      return MAX_ZOOM;
-    }
-    function pointToTileFraction(lon, lat, z) {
-      var sin2 = Math.sin(lat * d2r), z2 = Math.pow(2, z), x = z2 * (lon / 360 + 0.5), y = z2 * (0.5 - 0.25 * Math.log((1 + sin2) / (1 - sin2)) / Math.PI);
-      return [x, y, z];
-    }
-    module.exports = {
-      tileToGeoJSON,
-      tileToBBOX,
-      getChildren,
-      getParent,
-      getSiblings,
-      hasTile,
-      hasSiblings,
-      tilesEqual,
-      tileToQuadkey,
-      quadkeyToTile,
-      pointToTile,
-      bboxToTile,
-      pointToTileFraction
-    };
-  }
-});
-
-// node_modules/@mapbox/tile-cover/index.js
-var require_tile_cover = __commonJS({
-  "node_modules/@mapbox/tile-cover/index.js"(exports) {
-    "use strict";
-    var tilebelt = require_tilebelt();
-    exports.geojson = function(geom, limits) {
-      return {
-        type: "FeatureCollection",
-        features: getTiles(geom, limits).map(tileToFeature)
-      };
-    };
-    function tileToFeature(t) {
-      return {
-        type: "Feature",
-        geometry: tilebelt.tileToGeoJSON(t),
-        properties: {}
-      };
-    }
-    exports.tiles = getTiles;
-    exports.indexes = function(geom, limits) {
-      return getTiles(geom, limits).map(tilebelt.tileToQuadkey);
-    };
-    function getTiles(geom, limits) {
-      var i, tile, coords = geom.coordinates, maxZoom = limits.max_zoom, tileHash = {}, tiles2 = [];
-      if (geom.type === "Point") {
-        return [tilebelt.pointToTile(coords[0], coords[1], maxZoom)];
-      } else if (geom.type === "MultiPoint") {
-        for (i = 0; i < coords.length; i++) {
-          tile = tilebelt.pointToTile(coords[i][0], coords[i][1], maxZoom);
-          tileHash[toID(tile[0], tile[1], tile[2])] = true;
-        }
-      } else if (geom.type === "LineString") {
-        lineCover(tileHash, coords, maxZoom);
-      } else if (geom.type === "MultiLineString") {
-        for (i = 0; i < coords.length; i++) {
-          lineCover(tileHash, coords[i], maxZoom);
-        }
-      } else if (geom.type === "Polygon") {
-        polygonCover(tileHash, tiles2, coords, maxZoom);
-      } else if (geom.type === "MultiPolygon") {
-        for (i = 0; i < coords.length; i++) {
-          polygonCover(tileHash, tiles2, coords[i], maxZoom);
-        }
-      } else {
-        throw new Error("Geometry type not implemented");
-      }
-      if (limits.min_zoom !== maxZoom) {
-        var len = tiles2.length;
-        appendHashTiles(tileHash, tiles2);
-        for (i = 0; i < len; i++) {
-          var t = tiles2[i];
-          tileHash[toID(t[0], t[1], t[2])] = true;
-        }
-        return mergeTiles(tileHash, tiles2, limits);
-      }
-      appendHashTiles(tileHash, tiles2);
-      return tiles2;
-    }
-    function mergeTiles(tileHash, tiles2, limits) {
-      var mergedTiles = [];
-      for (var z = limits.max_zoom; z > limits.min_zoom; z--) {
-        var parentTileHash = {};
-        var parentTiles = [];
-        for (var i = 0; i < tiles2.length; i++) {
-          var t = tiles2[i];
-          if (t[0] % 2 === 0 && t[1] % 2 === 0) {
-            var id2 = toID(t[0] + 1, t[1], z), id3 = toID(t[0], t[1] + 1, z), id4 = toID(t[0] + 1, t[1] + 1, z);
-            if (tileHash[id2] && tileHash[id3] && tileHash[id4]) {
-              tileHash[toID(t[0], t[1], t[2])] = false;
-              tileHash[id2] = false;
-              tileHash[id3] = false;
-              tileHash[id4] = false;
-              var parentTile = [t[0] / 2, t[1] / 2, z - 1];
-              if (z - 1 === limits.min_zoom) mergedTiles.push(parentTile);
-              else {
-                parentTileHash[toID(t[0] / 2, t[1] / 2, z - 1)] = true;
-                parentTiles.push(parentTile);
-              }
-            }
-          }
-        }
-        for (i = 0; i < tiles2.length; i++) {
-          t = tiles2[i];
-          if (tileHash[toID(t[0], t[1], t[2])]) mergedTiles.push(t);
-        }
-        tileHash = parentTileHash;
-        tiles2 = parentTiles;
-      }
-      return mergedTiles;
-    }
-    function polygonCover(tileHash, tileArray, geom, zoom) {
-      var intersections = [];
-      for (var i = 0; i < geom.length; i++) {
-        var ring = [];
-        lineCover(tileHash, geom[i], zoom, ring);
-        for (var j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
-          var m = (j + 1) % len;
-          var y = ring[j][1];
-          if ((y > ring[k][1] || y > ring[m][1]) && // not local minimum
-          (y < ring[k][1] || y < ring[m][1]) && // not local maximum
-          y !== ring[m][1]) intersections.push(ring[j]);
-        }
-      }
-      intersections.sort(compareTiles);
-      for (i = 0; i < intersections.length; i += 2) {
-        y = intersections[i][1];
-        for (var x = intersections[i][0] + 1; x < intersections[i + 1][0]; x++) {
-          var id = toID(x, y, zoom);
-          if (!tileHash[id]) {
-            tileArray.push([x, y, zoom]);
-          }
-        }
-      }
-    }
-    function compareTiles(a, b) {
-      return a[1] - b[1] || a[0] - b[0];
-    }
-    function lineCover(tileHash, coords, maxZoom, ring) {
-      var prevX, prevY;
-      for (var i = 0; i < coords.length - 1; i++) {
-        var start = tilebelt.pointToTileFraction(coords[i][0], coords[i][1], maxZoom), stop = tilebelt.pointToTileFraction(coords[i + 1][0], coords[i + 1][1], maxZoom), x0 = start[0], y0 = start[1], x1 = stop[0], y1 = stop[1], dx = x1 - x0, dy = y1 - y0;
-        if (dy === 0 && dx === 0) continue;
-        var sx = dx > 0 ? 1 : -1, sy = dy > 0 ? 1 : -1, x = Math.floor(x0), y = Math.floor(y0), tMaxX = dx === 0 ? Infinity : Math.abs(((dx > 0 ? 1 : 0) + x - x0) / dx), tMaxY = dy === 0 ? Infinity : Math.abs(((dy > 0 ? 1 : 0) + y - y0) / dy), tdx = Math.abs(sx / dx), tdy = Math.abs(sy / dy);
-        if (x !== prevX || y !== prevY) {
-          tileHash[toID(x, y, maxZoom)] = true;
-          if (ring && y !== prevY) ring.push([x, y]);
-          prevX = x;
-          prevY = y;
-        }
-        while (tMaxX < 1 || tMaxY < 1) {
-          if (tMaxX < tMaxY) {
-            tMaxX += tdx;
-            x += sx;
-          } else {
-            tMaxY += tdy;
-            y += sy;
-          }
-          tileHash[toID(x, y, maxZoom)] = true;
-          if (ring && y !== prevY) ring.push([x, y]);
-          prevX = x;
-          prevY = y;
-        }
-      }
-      if (ring && y === ring[0][1]) ring.pop();
-    }
-    function appendHashTiles(hash, tiles2) {
-      var keys = Object.keys(hash);
-      for (var i = 0; i < keys.length; i++) {
-        tiles2.push(fromID(+keys[i]));
-      }
-    }
-    function toID(x, y, z) {
-      var dim = 2 * (1 << z);
-      return (dim * y + x) * 32 + z;
-    }
-    function fromID(id) {
-      var z = id % 32, dim = 2 * (1 << z), xy = (id - z) / 32, x = xy % dim, y = (xy - x) / dim % dim;
-      return [x, y, z];
-    }
-  }
-});
-
-// node_modules/thenby/thenBy.module.js
-var require_thenBy_module = __commonJS({
-  "node_modules/thenby/thenBy.module.js"(exports, module) {
-    "use strict";
-    module.exports = function() {
-      function identity(v) {
-        return v;
-      }
-      function ignoreCase(v) {
-        return typeof v === "string" ? v.toLowerCase() : v;
-      }
-      function makeCompareFunction(f, opt) {
-        opt = typeof opt === "object" ? opt : { direction: opt };
-        if (typeof f != "function") {
-          var prop = f;
-          f = function(v1) {
-            return !!v1[prop] ? v1[prop] : "";
-          };
-        }
-        if (f.length === 1) {
-          var uf = f;
-          var preprocess = opt.ignoreCase ? ignoreCase : identity;
-          var cmp = opt.cmp || function(v1, v2) {
-            return v1 < v2 ? -1 : v1 > v2 ? 1 : 0;
-          };
-          f = function(v1, v2) {
-            return cmp(preprocess(uf(v1)), preprocess(uf(v2)));
-          };
-        }
-        const descTokens = { "-1": "", desc: "" };
-        if (opt.direction in descTokens) return function(v1, v2) {
-          return -f(v1, v2);
-        };
-        return f;
-      }
-      function tb(func, opt) {
-        var x = typeof this == "function" && !this.firstBy ? this : false;
-        var y = makeCompareFunction(func, opt);
-        var f = x ? function(a, b) {
-          return x(a, b) || y(a, b);
-        } : y;
-        f.thenBy = tb;
-        return f;
-      }
-      tb.firstBy = tb;
-      return tb;
-    }();
-  }
-});
-
-// src/client.ts
-var client = "deck-gl-carto";
-function getClient() {
-  return client;
-}
-function setClient(c) {
-  client = c;
-}
-
-// src/constants.ts
-var FilterType = /* @__PURE__ */ ((FilterType2) => {
-  FilterType2["IN"] = "in";
-  FilterType2["BETWEEN"] = "between";
-  FilterType2["CLOSED_OPEN"] = "closed_open";
-  FilterType2["TIME"] = "time";
-  FilterType2["STRING_SEARCH"] = "stringSearch";
-  return FilterType2;
-})(FilterType || {});
-var ApiVersion = /* @__PURE__ */ ((ApiVersion2) => {
-  ApiVersion2["V1"] = "v1";
-  ApiVersion2["V2"] = "v2";
-  ApiVersion2["V3"] = "v3";
-  return ApiVersion2;
-})(ApiVersion || {});
-var DEFAULT_API_BASE_URL = "https://gcp-us-east1.api.carto.com";
-var TileFormat = /* @__PURE__ */ ((TileFormat2) => {
-  TileFormat2["MVT"] = "mvt";
-  TileFormat2["JSON"] = "json";
-  TileFormat2["GEOJSON"] = "geojson";
-  TileFormat2["BINARY"] = "binary";
-  return TileFormat2;
-})(TileFormat || {});
-var SpatialIndex = /* @__PURE__ */ ((SpatialIndex2) => {
-  SpatialIndex2["H3"] = "h3";
-  SpatialIndex2["S2"] = "s2";
-  SpatialIndex2["QUADBIN"] = "quadbin";
-  return SpatialIndex2;
-})(SpatialIndex || {});
-var Provider = /* @__PURE__ */ ((Provider2) => {
-  Provider2["BIGQUERY"] = "bigquery";
-  Provider2["REDSHIFT"] = "redshift";
-  Provider2["POSTGRES"] = "postgres";
-  Provider2["SNOWFLAKE"] = "snowflake";
-  Provider2["DATABRICKS"] = "databricks";
-  Provider2["DATABRICKS_REST"] = "databricksRest";
-  return Provider2;
-})(Provider || {});
-
-// src/utils/makeIntervalComplete.ts
-function makeIntervalComplete(intervals) {
-  return intervals.map((val) => {
-    if (val[0] === void 0 || val[0] === null) {
-      return [Number.MIN_SAFE_INTEGER, val[1]];
-    }
-    if (val[1] === void 0 || val[1] === null) {
-      return [val[0], Number.MAX_SAFE_INTEGER];
-    }
-    return val;
-  });
-}
-
-// src/filters/FilterTypes.ts
-var filterFunctions = {
-  ["in" /* IN */]: filterIn,
-  ["between" /* BETWEEN */]: filterBetween,
-  ["time" /* TIME */]: filterTime,
-  ["closed_open" /* CLOSED_OPEN */]: filterClosedOpen,
-  ["stringSearch" /* STRING_SEARCH */]: filterStringSearch
-};
-function filterIn(filterValues, featureValue) {
-  return filterValues.includes(featureValue);
-}
-function filterBetween(filterValues, featureValue) {
-  const checkRange = (range) => {
-    const [lowerBound, upperBound] = range;
-    return featureValue >= lowerBound && featureValue <= upperBound;
-  };
-  return makeIntervalComplete(filterValues).some(
-    checkRange
-  );
-}
-function filterTime(filterValues, featureValue) {
-  const featureValueAsTimestamp = new Date(featureValue).getTime();
-  if (isFinite(featureValueAsTimestamp)) {
-    return filterBetween(filterValues, featureValueAsTimestamp);
-  } else {
-    throw new Error(`Column used to filter by time isn't well formatted.`);
-  }
-}
-function filterClosedOpen(filterValues, featureValue) {
-  const checkRange = (range) => {
-    const [lowerBound, upperBound] = range;
-    return featureValue >= lowerBound && featureValue < upperBound;
-  };
-  return makeIntervalComplete(filterValues).some(
-    checkRange
-  );
-}
-function filterStringSearch(filterValues, featureValue, params = {}) {
-  const normalizedFeatureValue = normalize(featureValue, params);
-  const stringRegExp = params.useRegExp ? filterValues : filterValues.map((filterValue) => {
-    let stringRegExp2 = escapeRegExp(normalize(filterValue, params));
-    if (params.mustStart) stringRegExp2 = `^${stringRegExp2}`;
-    if (params.mustEnd) stringRegExp2 = `${stringRegExp2}$`;
-    return stringRegExp2;
-  });
-  const regex = new RegExp(
-    stringRegExp.join("|"),
-    params.caseSensitive ? "g" : "gi"
-  );
-  return !!normalizedFeatureValue.match(regex);
-}
-var specialCharRegExp = /[.*+?^${}()|[\]\\]/g;
-var normalizeRegExp = /\p{Diacritic}/gu;
-function escapeRegExp(value) {
-  return value.replace(specialCharRegExp, "\\$&");
-}
-function normalize(data, params) {
-  let normalizedData = String(data);
-  if (!params.keepSpecialCharacters)
-    normalizedData = normalizedData.normalize("NFD").replace(normalizeRegExp, "");
-  return normalizedData;
-}
-
-// src/filters/Filter.ts
-var LOGICAL_OPERATOR_METHODS = {
-  and: "every",
-  or: "some"
-};
-function passesFilter(columns, filters, feature, filtersLogicalOperator) {
-  const method = LOGICAL_OPERATOR_METHODS[filtersLogicalOperator];
-  return columns[method]((column) => {
-    const columnFilters = filters[column];
-    const columnFilterTypes = Object.keys(columnFilters);
-    if (!feature || feature[column] === null || feature[column] === void 0) {
-      return false;
-    }
-    return columnFilterTypes.every((filter) => {
-      const filterFunction = filterFunctions[filter];
-      if (!filterFunction) {
-        throw new Error(`"${filter}" filter is not implemented.`);
-      }
-      return filterFunction(
-        columnFilters[filter].values,
-        feature[column],
-        columnFilters[filter].params
-      );
-    });
-  });
-}
-function _buildFeatureFilter({
-  filters = {},
-  type = "boolean",
-  filtersLogicalOperator = "and"
-}) {
-  const columns = Object.keys(filters);
-  if (!columns.length) {
-    return () => type === "number" ? 1 : true;
-  }
-  return (feature) => {
-    const f = feature.properties || feature;
-    const featurePassesFilter = passesFilter(
-      columns,
-      filters,
-      f,
-      filtersLogicalOperator
-    );
-    return type === "number" ? Number(featurePassesFilter) : featurePassesFilter;
-  };
-}
-function applyFilters(features, filters, filtersLogicalOperator) {
-  return Object.keys(filters).length ? features.filter(_buildFeatureFilter({ filters, filtersLogicalOperator })) : features;
-}
-function buildBinaryFeatureFilter({ filters = {} }) {
-  const columns = Object.keys(filters);
-  if (!columns.length) {
-    return () => 1;
-  }
-  return (featureIdIdx, binaryData) => passesFilterUsingBinary(columns, filters, featureIdIdx, binaryData);
-}
-function getValueFromNumericProps(featureIdIdx, binaryData, { column }) {
-  return binaryData.numericProps?.[column]?.value[featureIdIdx];
-}
-function getValueFromProperties(featureIdIdx, binaryData, { column }) {
-  const propertyIdx = binaryData.featureIds.value[featureIdIdx];
-  return binaryData.properties[propertyIdx]?.[column];
-}
-var GET_VALUE_BY_BINARY_PROP = {
-  properties: getValueFromProperties,
-  numericProps: getValueFromNumericProps
-};
-function getBinaryPropertyByFilterValues(filterValues) {
-  return typeof filterValues.flat()[0] === "string" ? "properties" : "numericProps";
-}
-function getFeatureValue(featureIdIdx, binaryData, filter) {
-  const { column, values } = filter;
-  const binaryProp = getBinaryPropertyByFilterValues(values);
-  const getFeatureValueFn = GET_VALUE_BY_BINARY_PROP[binaryProp];
-  return getFeatureValueFn(featureIdIdx, binaryData, { column });
-}
-function passesFilterUsingBinary(columns, filters, featureIdIdx, binaryData) {
-  return columns.every((column) => {
-    const columnFilters = filters[column];
-    return Object.entries(columnFilters).every(([type, { values }]) => {
-      const filterFn = filterFunctions[type];
-      if (!filterFn) {
-        throw new Error(`"${type}" filter is not implemented.`);
-      }
-      if (!values) return 0;
-      const featureValue = getFeatureValue(featureIdIdx, binaryData, {
-        type,
-        column,
-        values
-      });
-      if (featureValue === void 0 || featureValue === null) return 0;
-      return filterFn(values, featureValue);
-    });
-  });
-}
-
-// src/filters/geosjonFeatures.ts
-import intersects from "@turf/boolean-intersects";
-function geojsonFeatures({
-  geojson,
-  spatialFilter,
-  uniqueIdProperty
-}) {
-  let uniqueIdx = 0;
-  const map = /* @__PURE__ */ new Map();
-  if (!spatialFilter) {
-    return [];
-  }
-  for (const feature of geojson.features) {
-    const uniqueId = uniqueIdProperty ? feature.properties[uniqueIdProperty] : ++uniqueIdx;
-    if (!map.has(uniqueId) && intersects(spatialFilter, feature)) {
-      map.set(uniqueId, feature.properties);
-    }
-  }
-  return Array.from(map.values());
-}
-
-// node_modules/@math.gl/core/dist/lib/common.js
-var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
-var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
-var DEFAULT_CONFIG = {
-  EPSILON: 1e-12,
-  debug: false,
-  precision: 4,
-  printTypes: false,
-  printDegrees: false,
-  printRowMajor: true,
-  _cartographicRadians: false
-};
-globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
-var config = globalThis.mathgl.config;
-function isArray(value) {
-  return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
-}
-function lerp(a, b, t) {
-  if (isArray(a)) {
-    return a.map((ai, i) => lerp(ai, b[i], t));
-  }
-  return t * b + (1 - t) * a;
-}
-
-// node_modules/@math.gl/web-mercator/dist/assert.js
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message || "@math.gl/web-mercator: assertion failed.");
-  }
-}
-
-// node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js
-var PI = Math.PI;
-var PI_4 = PI / 4;
-var DEGREES_TO_RADIANS2 = PI / 180;
-var RADIANS_TO_DEGREES2 = 180 / PI;
-var TILE_SIZE = 512;
-function lngLatToWorld(lngLat) {
-  const [lng, lat] = lngLat;
-  assert(Number.isFinite(lng));
-  assert(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude");
-  const lambda2 = lng * DEGREES_TO_RADIANS2;
-  const phi2 = lat * DEGREES_TO_RADIANS2;
-  const x = TILE_SIZE * (lambda2 + PI) / (2 * PI);
-  const y = TILE_SIZE * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5))) / (2 * PI);
-  return [x, y];
-}
-function worldToLngLat(xy) {
-  const [x, y] = xy;
-  const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
-  const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
-  return [lambda2 * RADIANS_TO_DEGREES2, phi2 * RADIANS_TO_DEGREES2];
-}
-
-// node_modules/@math.gl/web-mercator/dist/get-bounds.js
-var DEGREES_TO_RADIANS3 = Math.PI / 180;
-
-// src/utils/transformToTileCoords.ts
-var TRANSFORM_FN = {
-  Point: transformPoint,
-  MultiPoint: transformMultiPoint,
-  LineString: transformLineString,
-  MultiLineString: transformMultiLineString,
-  Polygon: transformPolygon,
-  MultiPolygon: transformMultiPolygon
-};
-function transformToTileCoords(geometry, bbox) {
-  const [west, south, east, north] = bbox;
-  const nw = projectFlat([west, north]);
-  const se = projectFlat([east, south]);
-  const projectedBbox = [nw, se];
-  if (geometry.type === "GeometryCollection") {
-    throw new Error("Unsupported geometry type GeometryCollection");
-  }
-  const transformFn = TRANSFORM_FN[geometry.type];
-  const coordinates = transformFn(geometry.coordinates, projectedBbox);
-  return { ...geometry, coordinates };
-}
-function transformPoint([pointX, pointY], [nw, se]) {
-  const x = inverseLerp(nw[0], se[0], pointX);
-  const y = inverseLerp(nw[1], se[1], pointY);
-  return [x, y];
-}
-function getPoints(geometry, bbox) {
-  return geometry.map((g) => transformPoint(projectFlat(g), bbox));
-}
-function transformMultiPoint(multiPoint, bbox) {
-  return getPoints(multiPoint, bbox);
-}
-function transformLineString(line, bbox) {
-  return getPoints(line, bbox);
-}
-function transformMultiLineString(multiLineString, bbox) {
-  return multiLineString.map(
-    (lineString) => transformLineString(lineString, bbox)
-  );
-}
-function transformPolygon(polygon, bbox) {
-  return polygon.map((polygonRing) => getPoints(polygonRing, bbox));
-}
-function transformMultiPolygon(multiPolygon, bbox) {
-  return multiPolygon.map((polygon) => transformPolygon(polygon, bbox));
-}
-function projectFlat(xyz) {
-  return lngLatToWorld(xyz);
-}
-function inverseLerp(a, b, x) {
-  return (x - a) / (b - a);
-}
-
-// src/filters/tileFeaturesGeometries.ts
-import bboxPolygon from "@turf/bbox-polygon";
-import intersects2 from "@turf/boolean-intersects";
-import booleanWithin from "@turf/boolean-within";
-import intersect from "@turf/intersect";
-
-// src/utils/transformTileCoordsToWGS84.ts
-var TRANSFORM_FN2 = {
-  Point: transformPoint2,
-  MultiPoint: transformMultiPoint2,
-  LineString: transformLineString2,
-  MultiLineString: transformMultiLineString2,
-  Polygon: transformPolygon2,
-  MultiPolygon: transformMultiPolygon2
-};
-function transformTileCoordsToWGS84(geometry, bbox) {
-  const [west, south, east, north] = bbox;
-  const nw = lngLatToWorld([west, north]);
-  const se = lngLatToWorld([east, south]);
-  const projectedBbox = [nw, se];
-  if (geometry.type === "GeometryCollection") {
-    throw new Error("Unsupported geometry type GeometryCollection");
-  }
-  const transformFn = TRANSFORM_FN2[geometry.type];
-  const coordinates = transformFn(geometry.coordinates, projectedBbox);
-  return { ...geometry, coordinates };
-}
-function transformPoint2([pointX, pointY], [nw, se]) {
-  const x = lerp(nw[0], se[0], pointX);
-  const y = lerp(nw[1], se[1], pointY);
-  return worldToLngLat([x, y]);
-}
-function getPoints2(geometry, bbox) {
-  return geometry.map((g) => transformPoint2(g, bbox));
-}
-function transformMultiPoint2(multiPoint, bbox) {
-  return getPoints2(multiPoint, bbox);
-}
-function transformLineString2(line, bbox) {
-  return getPoints2(line, bbox);
-}
-function transformMultiLineString2(multiLineString, bbox) {
-  return multiLineString.map(
-    (lineString) => transformLineString2(lineString, bbox)
-  );
-}
-function transformPolygon2(polygon, bbox) {
-  return polygon.map((polygonRing) => getPoints2(polygonRing, bbox));
-}
-function transformMultiPolygon2(multiPolygon, bbox) {
-  return multiPolygon.map((polygon) => transformPolygon2(polygon, bbox));
-}
-
-// src/filters/tileFeaturesGeometries.ts
-import { featureCollection } from "@turf/helpers";
-var FEATURE_GEOM_PROPERTY = "__geomValue";
-function tileFeaturesGeometries({
-  tiles: tiles2,
-  tileFormat,
-  spatialFilter,
-  uniqueIdProperty,
-  options
-}) {
-  const map = /* @__PURE__ */ new Map();
-  for (const tile of tiles2) {
-    if (tile.isVisible === false || !tile.data) {
-      continue;
-    }
-    const bbox = [
-      tile.bbox.west,
-      tile.bbox.south,
-      tile.bbox.east,
-      tile.bbox.north
-    ];
-    const bboxToGeom = bboxPolygon(bbox);
-    const tileIsFullyVisible = booleanWithin(bboxToGeom, spatialFilter);
-    const spatialFilterFeature = {
-      type: "Feature",
-      geometry: spatialFilter,
-      properties: {}
-    };
-    const clippedGeometryToIntersect = intersect(
-      featureCollection([bboxToGeom, spatialFilterFeature])
-    );
-    if (!clippedGeometryToIntersect) {
-      continue;
-    }
-    const transformedGeometryToIntersect = tileFormat === "mvt" /* MVT */ ? transformToTileCoords(clippedGeometryToIntersect.geometry, bbox) : clippedGeometryToIntersect.geometry;
-    createIndicesForPoints(tile.data.points);
-    calculateFeatures({
-      map,
-      tileIsFullyVisible,
-      geometryIntersection: transformedGeometryToIntersect,
-      data: tile.data.points,
-      type: "Point",
-      bbox,
-      tileFormat,
-      uniqueIdProperty,
-      options
-    });
-    calculateFeatures({
-      map,
-      tileIsFullyVisible,
-      geometryIntersection: transformedGeometryToIntersect,
-      data: tile.data.lines,
-      type: "LineString",
-      bbox,
-      tileFormat,
-      uniqueIdProperty,
-      options
-    });
-    calculateFeatures({
-      map,
-      tileIsFullyVisible,
-      geometryIntersection: transformedGeometryToIntersect,
-      data: tile.data.polygons,
-      type: "Polygon",
-      bbox,
-      tileFormat,
-      uniqueIdProperty,
-      options
-    });
-  }
-  return Array.from(map.values());
-}
-function processTileFeatureProperties({
-  map,
-  data,
-  startIndex,
-  endIndex,
-  type,
-  bbox,
-  tileFormat,
-  uniqueIdProperty,
-  storeGeometry,
-  geometryIntersection
-}) {
-  const tileProps = getPropertiesFromTile(data, startIndex);
-  const uniquePropertyValue = getUniquePropertyValue(
-    tileProps,
-    uniqueIdProperty,
-    map
-  );
-  if (!uniquePropertyValue || map.has(uniquePropertyValue)) {
-    return;
-  }
-  let geometry = null;
-  if (storeGeometry || geometryIntersection) {
-    const { positions } = data;
-    const ringCoordinates = getRingCoordinatesFor(
-      startIndex,
-      endIndex,
-      positions
-    );
-    geometry = getFeatureByType(ringCoordinates, type);
-  }
-  if (geometry && geometryIntersection && !intersects2(geometry, geometryIntersection)) {
-    return;
-  }
-  const properties = parseProperties(tileProps);
-  if (storeGeometry && geometry) {
-    properties[FEATURE_GEOM_PROPERTY] = tileFormat === "mvt" /* MVT */ ? transformTileCoordsToWGS84(geometry, bbox) : geometry;
-  }
-  map.set(uniquePropertyValue, properties);
-}
-function addIntersectedFeaturesInTile({
-  map,
-  data,
-  geometryIntersection,
-  type,
-  bbox,
-  tileFormat,
-  uniqueIdProperty,
-  options
-}) {
-  const indices = getIndices(data);
-  const storeGeometry = options?.storeGeometry || false;
-  for (let i = 0; i < indices.length - 1; i++) {
-    const startIndex = indices[i];
-    const endIndex = indices[i + 1];
-    processTileFeatureProperties({
-      map,
-      data,
-      startIndex,
-      endIndex,
-      type,
-      bbox,
-      tileFormat,
-      uniqueIdProperty,
-      storeGeometry,
-      geometryIntersection
-    });
-  }
-}
-function getIndices(data) {
-  let indices;
-  switch (data.type) {
-    case "Point":
-      indices = data.pointIndices;
-      break;
-    case "LineString":
-      indices = data.pathIndices;
-      break;
-    case "Polygon":
-      indices = data.primitivePolygonIndices;
-      break;
-    default:
-      throw new Error(`Unexpected type, "${data.type}"`);
-  }
-  return indices.value;
-}
-function getFeatureId(data, startIndex) {
-  return data.featureIds.value[startIndex];
-}
-function getPropertiesFromTile(data, startIndex) {
-  const featureId = getFeatureId(data, startIndex);
-  const { properties, numericProps, fields } = data;
-  const result = {
-    uniqueId: fields?.[featureId]?.id,
-    properties: properties[featureId],
-    numericProps: {}
-  };
-  for (const key in numericProps) {
-    result.numericProps[key] = numericProps[key].value[startIndex];
-  }
-  return result;
-}
-function parseProperties(tileProps) {
-  const { properties, numericProps } = tileProps;
-  return Object.assign({}, properties, numericProps);
-}
-function getUniquePropertyValue(tileProps, uniqueIdProperty, map) {
-  if (uniqueIdProperty) {
-    return getValueFromTileProps(tileProps, uniqueIdProperty);
-  }
-  if (tileProps.uniqueId) {
-    return tileProps.uniqueId;
-  }
-  const artificialId = map.size + 1;
-  return getValueFromTileProps(tileProps, "cartodb_id") || getValueFromTileProps(tileProps, "geoid") || artificialId;
-}
-function getValueFromTileProps(tileProps, propertyName) {
-  const { properties, numericProps } = tileProps;
-  return numericProps[propertyName] || properties[propertyName];
-}
-function getFeatureByType(coordinates, type) {
-  switch (type) {
-    case "Polygon":
-      return { type: "Polygon", coordinates: [coordinates] };
-    case "LineString":
-      return { type: "LineString", coordinates };
-    case "Point":
-      return { type: "Point", coordinates: coordinates[0] };
-    default:
-      throw new Error("Invalid geometry type");
-  }
-}
-function getRingCoordinatesFor(startIndex, endIndex, positions) {
-  const ringCoordinates = [];
-  for (let j = startIndex; j < endIndex; j++) {
-    ringCoordinates.push(
-      Array.from(
-        positions.value.subarray(j * positions.size, (j + 1) * positions.size)
-      )
-    );
-  }
-  return ringCoordinates;
-}
-function calculateFeatures({
-  map,
-  tileIsFullyVisible,
-  geometryIntersection,
-  data,
-  type,
-  bbox,
-  tileFormat,
-  uniqueIdProperty,
-  options
-}) {
-  if (!data?.properties.length) {
-    return;
-  }
-  if (tileIsFullyVisible) {
-    addAllFeaturesInTile({
-      map,
-      data,
-      type,
-      bbox,
-      tileFormat,
-      uniqueIdProperty,
-      options
-    });
-  } else {
-    addIntersectedFeaturesInTile({
-      map,
-      data,
-      geometryIntersection,
-      type,
-      bbox,
-      tileFormat,
-      uniqueIdProperty,
-      options
-    });
-  }
-}
-function addAllFeaturesInTile({
-  map,
-  data,
-  type,
-  bbox,
-  tileFormat,
-  uniqueIdProperty,
-  options
-}) {
-  const indices = getIndices(data);
-  const storeGeometry = options?.storeGeometry || false;
-  for (let i = 0; i < indices.length - 1; i++) {
-    const startIndex = indices[i];
-    const endIndex = indices[i + 1];
-    processTileFeatureProperties({
-      map,
-      data,
-      startIndex,
-      endIndex,
-      type,
-      bbox,
-      tileFormat,
-      uniqueIdProperty,
-      storeGeometry
-    });
-  }
-}
-function createIndicesForPoints(data) {
-  const featureIds = data.featureIds.value;
-  const lastFeatureId = featureIds[featureIds.length - 1];
-  const PointIndicesArray = featureIds.constructor;
-  const pointIndices = {
-    value: new PointIndicesArray(featureIds.length + 1),
-    size: 1
-  };
-  pointIndices.value.set(featureIds);
-  pointIndices.value.set([lastFeatureId + 1], featureIds.length);
-  data.pointIndices = pointIndices;
-}
-
-// node_modules/quadbin/dist/esm/index.js
-var import_tile_cover = __toESM(require_tile_cover(), 1);
-var B = [
-  0x5555555555555555n,
-  0x3333333333333333n,
-  0x0f0f0f0f0f0f0f0fn,
-  0x00ff00ff00ff00ffn,
-  0x0000ffff0000ffffn,
-  0x00000000ffffffffn
-];
-var S = [0n, 1n, 2n, 4n, 8n, 16n];
-function tileToCell(tile) {
-  if (tile.z < 0 || tile.z > 26) {
-    throw new Error("Wrong zoom");
-  }
-  const z = BigInt(tile.z);
-  let x = BigInt(tile.x) << 32n - z;
-  let y = BigInt(tile.y) << 32n - z;
-  for (let i = 0; i < 5; i++) {
-    const s = S[5 - i];
-    const b = B[4 - i];
-    x = (x | x << s) & b;
-    y = (y | y << s) & b;
-  }
-  const quadbin = 0x4000000000000000n | 1n << 59n | // | (mode << 59) | (mode_dep << 57)
-  z << 52n | (x | y << 1n) >> 12n | 0xfffffffffffffn >> z * 2n;
-  return quadbin;
-}
-function getResolution(quadbin) {
-  return quadbin >> 52n & 0x1fn;
-}
-function geometryToCells(geometry, resolution) {
-  const zoom = Number(resolution);
-  return (0, import_tile_cover.tiles)(geometry, {
-    min_zoom: zoom,
-    max_zoom: zoom
-  }).map(([x, y, z]) => tileToCell({ x, y, z }));
-}
-
-// src/filters/tileFeaturesSpatialIndex.ts
-import bboxClip from "@turf/bbox-clip";
-import { getResolution as h3GetResolution, polygonToCells } from "h3-js";
-function tileFeaturesSpatialIndex({
-  tiles: tiles2,
-  spatialFilter,
-  spatialDataColumn,
-  spatialDataType
-}) {
-  const map = /* @__PURE__ */ new Map();
-  const spatialIndex = getSpatialIndex(spatialDataType);
-  const resolution = getResolution2(tiles2, spatialIndex);
-  const spatialIndexIDName = spatialDataColumn ? spatialDataColumn : spatialIndex;
-  if (!resolution) {
-    return [];
-  }
-  const cells = getCellsCoverGeometry(spatialFilter, spatialIndex, resolution);
-  if (!cells?.length) {
-    return [];
-  }
-  const cellsSet = new Set(cells);
-  for (const tile of tiles2) {
-    if (tile.isVisible === false || !tile.data) {
-      continue;
-    }
-    tile.data.forEach((d) => {
-      if (cellsSet.has(d.id)) {
-        map.set(d.id, { ...d.properties, [spatialIndexIDName]: d.id });
-      }
-    });
-  }
-  return Array.from(map.values());
-}
-function getResolution2(tiles2, spatialIndex) {
-  const data = tiles2.find((tile) => tile.data?.length)?.data;
-  if (!data) {
-    return;
-  }
-  if (spatialIndex === "quadbin" /* QUADBIN */) {
-    return Number(getResolution(data[0].id));
-  }
-  if (spatialIndex === "h3" /* H3 */) {
-    return h3GetResolution(data[0].id);
-  }
-}
-var bboxWest = [-180, -90, 0, 90];
-var bboxEast = [0, -90, 180, 90];
-function getCellsCoverGeometry(geometry, spatialIndex, resolution) {
-  if (spatialIndex === "quadbin" /* QUADBIN */) {
-    return geometryToCells(geometry, resolution);
-  }
-  if (spatialIndex === "h3" /* H3 */) {
-    return polygonToCells(
-      bboxClip(geometry, bboxWest).geometry.coordinates,
-      resolution,
-      true
-    ).concat(
-      polygonToCells(
-        bboxClip(geometry, bboxEast).geometry.coordinates,
-        resolution,
-        true
-      )
-    );
-  }
-}
-function getSpatialIndex(spatialDataType) {
-  switch (spatialDataType) {
-    case "h3":
-      return "h3" /* H3 */;
-    case "quadbin":
-      return "quadbin" /* QUADBIN */;
-    default:
-      throw new Error("Unexpected spatial data type");
-  }
-}
-
-// src/constants-internal.ts
-var V3_MINOR_VERSION = "3.4";
-var DEFAULT_GEO_COLUMN = "geom";
-var DEFAULT_MAX_LENGTH_URL = 7e3;
-var DEFAULT_TILE_RESOLUTION = 0.5;
-var DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
-var DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
-
-// src/filters/tileFeatures.ts
-function tileFeatures({
-  tiles: tiles2,
-  spatialFilter,
-  uniqueIdProperty,
-  tileFormat,
-  spatialDataColumn = DEFAULT_GEO_COLUMN,
-  spatialDataType,
-  options = {}
-}) {
-  if (spatialDataType !== "geo") {
-    return tileFeaturesSpatialIndex({
-      tiles: tiles2,
-      spatialFilter,
-      spatialDataColumn,
-      spatialDataType
-    });
-  }
-  return tileFeaturesGeometries({
-    tiles: tiles2,
-    tileFormat,
-    spatialFilter,
-    uniqueIdProperty,
-    options
-  });
-}
-
-// src/spatial-index.ts
-var DEFAULT_TILE_SIZE = 512;
-var QUADBIN_ZOOM_MAX_OFFSET = 4;
-function getSpatialFiltersResolution(source, viewState) {
-  const dataResolution = source.dataResolution ?? Number.MAX_VALUE;
-  const aggregationResLevel = source.aggregationResLevel ?? (source.spatialDataType === "h3" ? DEFAULT_AGGREGATION_RES_LEVEL_H3 : DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN);
-  const aggregationResLevelOffset = Math.max(
-    0,
-    Math.floor(aggregationResLevel)
-  );
-  const currentZoomInt = Math.ceil(viewState.zoom);
-  if (source.spatialDataType === "h3") {
-    const tileSize = DEFAULT_TILE_SIZE;
-    const maxResolutionForZoom = maxH3SpatialFiltersResolutions.find(
-      ([zoom]) => zoom === currentZoomInt
-    )?.[1] ?? Math.max(0, currentZoomInt - 3);
-    const maxSpatialFiltersResolution = maxResolutionForZoom ? Math.min(dataResolution, maxResolutionForZoom) : dataResolution;
-    const hexagonResolution = _getHexagonResolution(viewState, tileSize) + aggregationResLevelOffset;
-    return Math.min(hexagonResolution, maxSpatialFiltersResolution);
-  }
-  if (source.spatialDataType === "quadbin") {
-    const maxResolutionForZoom = currentZoomInt + QUADBIN_ZOOM_MAX_OFFSET;
-    const maxSpatialFiltersResolution = Math.min(
-      dataResolution,
-      maxResolutionForZoom
-    );
-    const quadsResolution = Math.floor(viewState.zoom) + aggregationResLevelOffset;
-    return Math.min(quadsResolution, maxSpatialFiltersResolution);
-  }
-  return void 0;
-}
-var maxH3SpatialFiltersResolutions = [
-  [20, 14],
-  [19, 13],
-  [18, 12],
-  [17, 11],
-  [16, 10],
-  [15, 9],
-  [14, 8],
-  [13, 7],
-  [12, 7],
-  [11, 7],
-  [10, 6],
-  [9, 6],
-  [8, 5],
-  [7, 4],
-  [6, 4],
-  [5, 3],
-  [4, 2],
-  [3, 1],
-  [2, 1],
-  [1, 0]
-];
-var BIAS = 2;
-function _getHexagonResolution(viewport, tileSize) {
-  const zoomOffset = Math.log2(tileSize / DEFAULT_TILE_SIZE);
-  const hexagonScaleFactor = 2 / 3 * (viewport.zoom - zoomOffset);
-  const latitudeScaleFactor = Math.log(
-    1 / Math.cos(Math.PI * viewport.latitude / 180)
-  );
-  return Math.max(
-    0,
-    Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS)
-  );
-}
-
-// src/widget-sources/widget-source.ts
-var _WidgetSource = class _WidgetSource {
-  constructor(props) {
-    __publicField(this, "props");
-    this.props = { ..._WidgetSource.defaultProps, ...props };
-  }
-  _getSpatialFiltersResolution(source, spatialFilter, referenceViewState) {
-    if (!spatialFilter || source.spatialDataType === "geo") {
-      return;
-    }
-    if (!referenceViewState) {
-      throw new Error(
-        'Missing required option, "spatialIndexReferenceViewState".'
-      );
-    }
-    return getSpatialFiltersResolution(source, referenceViewState);
-  }
-};
-__publicField(_WidgetSource, "defaultProps", {
-  apiVersion: "v3" /* V3 */,
-  apiBaseUrl: DEFAULT_API_BASE_URL,
-  clientId: getClient(),
-  filters: {},
-  filtersLogicalOperator: "and"
-});
-var WidgetSource = _WidgetSource;
-
-// src/operations/aggregation.ts
-var aggregationFunctions = {
-  count: (values) => values.length,
-  min: (...args) => applyAggregationFunction(min, ...args),
-  max: (...args) => applyAggregationFunction(max, ...args),
-  sum: (...args) => applyAggregationFunction(sum, ...args),
-  avg: (...args) => applyAggregationFunction(avg, ...args)
-};
-function aggregate(feature, keys, operation) {
-  if (!keys?.length) {
-    throw new Error("Cannot aggregate a feature without having keys");
-  } else if (keys.length === 1) {
-    const value = feature[keys[0]];
-    return isPotentiallyValidNumber(value) ? Number(value) : value;
-  }
-  const aggregationFn = aggregationFunctions[operation];
-  if (!aggregationFn) {
-    throw new Error(`${operation} isn't a valid aggregation function`);
-  }
-  return aggregationFn(
-    keys.map((column) => {
-      const value = feature[column];
-      return isPotentiallyValidNumber(value) ? Number(value) : value;
-    })
-  );
-}
-function isPotentiallyValidNumber(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-var applyAggregationFunction = (aggFn, values, keys, operation) => {
-  const normalizedKeys = normalizeKeys(keys);
-  const elements = (normalizedKeys?.length || 0) <= 1 ? filterFalsyElements(values, normalizedKeys || []) : values;
-  return aggFn(elements, keys, operation);
-};
-function filterFalsyElements(values, keys) {
-  const filterFn = (value) => value !== null && value !== void 0;
-  if (!keys?.length) {
-    return values.filter(filterFn);
-  }
-  return values.filter((v) => filterFn(v[keys[0]]));
-}
-function avg(values, keys, joinOperation) {
-  return sum(values, keys, joinOperation) / (values.length || 1);
-}
-function sum(values, keys, joinOperation) {
-  const normalizedKeys = normalizeKeys(keys);
-  if (normalizedKeys) {
-    return values.reduce(
-      (a, b) => a + aggregate(b, normalizedKeys, joinOperation),
-      0
-    );
-  }
-  return values.reduce((a, b) => a + b, 0);
-}
-function min(values, keys, joinOperation) {
-  const normalizedKeys = normalizeKeys(keys);
-  if (normalizedKeys) {
-    return values.reduce(
-      (a, b) => Math.min(a, aggregate(b, normalizedKeys, joinOperation)),
-      Infinity
-    );
-  }
-  return Math.min(...values);
-}
-function max(values, keys, joinOperation) {
-  const normalizedKeys = normalizeKeys(keys);
-  if (normalizedKeys) {
-    return values.reduce(
-      (a, b) => Math.max(a, aggregate(b, normalizedKeys, joinOperation)),
-      -Infinity
-    );
-  }
-  return Math.max(...values);
-}
-function normalizeKeys(keys) {
-  return Array.isArray(keys) ? keys : typeof keys === "string" ? [keys] : void 0;
-}
-
-// src/operations/applySorting.ts
-var import_thenby = __toESM(require_thenBy_module(), 1);
-function applySorting(features, {
-  sortBy,
-  sortByDirection = "asc",
-  sortByColumnType = "string"
-} = {}) {
-  if (sortBy === void 0) {
-    return features;
-  }
-  const isValidSortBy = Array.isArray(sortBy) && sortBy.length || // sortBy can be an array of columns
-  typeof sortBy === "string";
-  if (!isValidSortBy) {
-    throw new Error("Sorting options are bad formatted");
-  }
-  const sortFn = createSortFn({
-    sortBy,
-    sortByDirection,
-    sortByColumnType: sortByColumnType || "string"
-  });
-  return features.sort(sortFn);
-}
-function createSortFn({
-  sortBy,
-  sortByDirection,
-  sortByColumnType
-}) {
-  const [firstSortOption, ...othersSortOptions] = normalizeSortByOptions({
-    sortBy,
-    sortByDirection,
-    sortByColumnType
-  });
-  let sortFn = (0, import_thenby.firstBy)(...firstSortOption);
-  for (const sortOptions of othersSortOptions) {
-    sortFn = sortFn.thenBy(...sortOptions);
-  }
-  return sortFn;
-}
-function normalizeSortByOptions({
-  sortBy,
-  sortByDirection,
-  sortByColumnType
-}) {
-  const numberFormat = sortByColumnType === "number" && {
-    cmp: (a, b) => a - b
-  };
-  if (!Array.isArray(sortBy)) {
-    sortBy = [sortBy];
-  }
-  return sortBy.map((sortByEl) => {
-    if (typeof sortByEl === "string") {
-      return [sortByEl, { direction: sortByDirection, ...numberFormat }];
-    }
-    if (Array.isArray(sortByEl)) {
-      if (sortByEl[1] === void 0) {
-        return [sortByEl, { direction: sortByDirection, ...numberFormat }];
-      }
-      if (typeof sortByEl[1] === "object") {
-        const othersSortOptions = numberFormat ? { ...numberFormat, ...sortByEl[1] } : sortByEl[1];
-        return [
-          sortByEl[0],
-          { direction: sortByDirection, ...othersSortOptions }
-        ];
-      }
-    }
-    return sortByEl;
-  });
-}
-
-// src/operations/groupBy.ts
-function groupValuesByColumn({
-  data,
-  valuesColumns,
-  joinOperation,
-  keysColumn,
-  operation
-}) {
-  if (Array.isArray(data) && data.length === 0) {
-    return null;
-  }
-  const groups = data.reduce((accumulator, item) => {
-    const group = item[keysColumn];
-    const values = accumulator.get(group) || [];
-    accumulator.set(group, values);
-    const aggregatedValue = aggregate(item, valuesColumns, joinOperation);
-    const isValid = (operation === "count" ? true : aggregatedValue !== null) && aggregatedValue !== void 0;
-    if (isValid) {
-      values.push(aggregatedValue);
-      accumulator.set(group, values);
-    }
-    return accumulator;
-  }, /* @__PURE__ */ new Map());
-  const targetOperation = aggregationFunctions[operation];
-  if (targetOperation) {
-    return Array.from(groups).map(([name, value]) => ({
-      name,
-      value: targetOperation(value)
-    }));
-  }
-  return [];
-}
-
-// src/utils/dateUtils.ts
-function getUTCMonday(date) {
-  const dateCp = new Date(date);
-  const day = dateCp.getUTCDay();
-  const diff = dateCp.getUTCDate() - day + (day ? 1 : -6);
-  dateCp.setUTCDate(diff);
-  return Date.UTC(
-    dateCp.getUTCFullYear(),
-    dateCp.getUTCMonth(),
-    dateCp.getUTCDate()
-  );
-}
-
-// src/operations/groupByDate.ts
-var GROUP_KEY_FN_MAPPING = {
-  year: (date) => Date.UTC(date.getUTCFullYear()),
-  month: (date) => Date.UTC(date.getUTCFullYear(), date.getUTCMonth()),
-  week: (date) => getUTCMonday(date),
-  day: (date) => Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()),
-  hour: (date) => Date.UTC(
-    date.getUTCFullYear(),
-    date.getUTCMonth(),
-    date.getUTCDate(),
-    date.getUTCHours()
-  ),
-  minute: (date) => Date.UTC(
-    date.getUTCFullYear(),
-    date.getUTCMonth(),
-    date.getUTCDate(),
-    date.getUTCHours(),
-    date.getUTCMinutes()
-  ),
-  second: (date) => Date.UTC(
-    date.getUTCFullYear(),
-    date.getUTCMonth(),
-    date.getUTCDate(),
-    date.getUTCHours(),
-    date.getUTCMinutes(),
-    date.getUTCSeconds()
-  )
-};
-function groupValuesByDateColumn({
-  data,
-  valuesColumns,
-  joinOperation,
-  keysColumn,
-  groupType,
-  operation
-}) {
-  if (Array.isArray(data) && data.length === 0) {
-    return null;
-  }
-  const groupKeyFn = GROUP_KEY_FN_MAPPING[groupType];
-  if (!groupKeyFn) {
-    return null;
-  }
-  const groups = data.reduce((acc, item) => {
-    const value = item[keysColumn];
-    const formattedValue = new Date(value);
-    const groupKey = groupKeyFn(formattedValue);
-    if (!isNaN(groupKey)) {
-      let groupedValues = acc.get(groupKey);
-      if (!groupedValues) {
-        groupedValues = [];
-        acc.set(groupKey, groupedValues);
-      }
-      const aggregatedValue = aggregate(item, valuesColumns, joinOperation);
-      const isValid = aggregatedValue !== null && aggregatedValue !== void 0;
-      if (isValid) {
-        groupedValues.push(aggregatedValue);
-        acc.set(groupKey, groupedValues);
-      }
-    }
-    return acc;
-  }, /* @__PURE__ */ new Map());
-  const targetOperation = aggregationFunctions[operation];
-  return [...groups.entries()].map(([name, value]) => ({
-    name,
-    value: targetOperation(value)
-  })).sort((a, b) => a.name - b.name);
-}
-
-// src/operations/histogram.ts
-function histogram({
-  data,
-  valuesColumns,
-  joinOperation,
-  ticks,
-  operation
-}) {
-  if (Array.isArray(data) && data.length === 0) {
-    return [];
-  }
-  const binsContainer = [Number.MIN_SAFE_INTEGER, ...ticks].map(
-    (tick, index, arr) => ({
-      bin: index,
-      start: tick,
-      end: index === arr.length - 1 ? Number.MAX_SAFE_INTEGER : arr[index + 1],
-      values: []
-    })
-  );
-  data.forEach((feature) => {
-    const featureValue = aggregate(
-      feature,
-      valuesColumns,
-      joinOperation
-    );
-    const isValid = featureValue !== null && featureValue !== void 0;
-    if (!isValid) {
-      return;
-    }
-    const binContainer = binsContainer.find(
-      (bin) => bin.start <= featureValue && bin.end > featureValue
-    );
-    if (!binContainer) {
-      return;
-    }
-    binContainer.values.push(featureValue);
-  });
-  const targetOperation = aggregationFunctions[operation];
-  const transformedBins = binsContainer.map(
-    (binContainer) => binContainer.values
-  );
-  return transformedBins.map(
-    (values) => values.length ? targetOperation(values) : 0
-  );
-}
-
-// src/operations/scatterPlot.ts
-function scatterPlot({
-  data,
-  xAxisColumns,
-  xAxisJoinOperation,
-  yAxisColumns,
-  yAxisJoinOperation
-}) {
-  return data.reduce(
-    (acc, feature) => {
-      const xValue = aggregate(
-        feature,
-        xAxisColumns,
-        xAxisJoinOperation
-      );
-      const xIsValid = xValue !== null && xValue !== void 0;
-      const yValue = aggregate(
-        feature,
-        yAxisColumns,
-        yAxisJoinOperation
-      );
-      const yIsValid = yValue !== null && yValue !== void 0;
-      if (xIsValid && yIsValid) {
-        acc.push([xValue, yValue]);
-      }
-      return acc;
-    },
-    []
-  );
-}
-
-// src/utils.ts
-var FILTER_TYPES = new Set(Object.values(FilterType));
-var isFilterType = (type) => FILTER_TYPES.has(type);
-function getApplicableFilters(owner, filters) {
-  if (!filters) return {};
-  const applicableFilters = {};
-  for (const column in filters) {
-    for (const type in filters[column]) {
-      if (!isFilterType(type)) continue;
-      const filter = filters[column][type];
-      const isApplicable = !owner || !filter?.owner || filter?.owner !== owner;
-      if (filter && isApplicable) {
-        applicableFilters[column] || (applicableFilters[column] = {});
-        applicableFilters[column][type] = filter;
-      }
-    }
-  }
-  return applicableFilters;
-}
-function normalizeObjectKeys(el) {
-  if (Array.isArray(el)) {
-    return el.map((value) => normalizeObjectKeys(value));
-  } else if (typeof el !== "object") {
-    return el;
-  }
-  return Object.entries(el).reduce(
-    (acc, [key, value]) => {
-      acc[key.toLowerCase()] = typeof value === "object" && value ? normalizeObjectKeys(value) : value;
-      return acc;
-    },
-    {}
-  );
-}
-function assert2(condition, message) {
-  if (!condition) {
-    throw new Error(message);
-  }
-}
-var _InvalidColumnError = class _InvalidColumnError extends Error {
-  constructor(message) {
-    super(`${_InvalidColumnError.NAME}: ${message}`);
-    this.name = _InvalidColumnError.NAME;
-  }
-  static is(error) {
-    return error instanceof _InvalidColumnError || error.message?.includes(_InvalidColumnError.NAME);
-  }
-};
-__publicField(_InvalidColumnError, "NAME", "InvalidColumnError");
-var InvalidColumnError = _InvalidColumnError;
-function isEmptyObject(object) {
-  for (const _ in object) {
-    return false;
-  }
-  return true;
-}
-var isObject = (x) => x !== null && typeof x === "object";
-var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
-
-// src/widget-sources/widget-tileset-source.ts
-import { booleanEqual } from "@turf/boolean-equal";
-var WidgetTilesetSource = class extends WidgetSource {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "_tiles", []);
-    __publicField(this, "_features", []);
-    __publicField(this, "_tileFeatureExtractOptions", {});
-    __publicField(this, "_tileFeatureExtractPreviousInputs", {});
-  }
-  /**
-   * Loads features as a list of tiles (typically provided by deck.gl).
-   * After tiles are loaded, {@link extractTileFeatures} must be called
-   * before computing statistics on the tiles.
-   */
-  loadTiles(tiles2) {
-    this._tiles = tiles2;
-    this._features.length = 0;
-  }
-  /** Configures options used to extract features from tiles. */
-  setTileFeatureExtractOptions(options) {
-    this._tileFeatureExtractOptions = options;
-    this._features.length = 0;
-  }
-  _extractTileFeatures(spatialFilter) {
-    const prevInputs = this._tileFeatureExtractPreviousInputs;
-    if (this._features.length && prevInputs.spatialFilter && booleanEqual(prevInputs.spatialFilter, spatialFilter)) {
-      return;
-    }
-    this._features = tileFeatures({
-      tiles: this._tiles,
-      tileFormat: this.props.tileFormat,
-      ...this._tileFeatureExtractOptions,
-      spatialFilter,
-      spatialDataColumn: this.props.spatialDataColumn,
-      spatialDataType: this.props.spatialDataType
-    });
-    prevInputs.spatialFilter = spatialFilter;
-  }
-  /**
-   * Loads features as GeoJSON (used for testing).
-   * @experimental
-   * @internal Not for public use. Spatial filters in other method calls will be ignored.
-   */
-  loadGeoJSON({
-    geojson,
-    spatialFilter
-  }) {
-    this._features = geojsonFeatures({
-      geojson,
-      spatialFilter,
-      ...this._tileFeatureExtractOptions
-    });
-    this._tileFeatureExtractPreviousInputs.spatialFilter = spatialFilter;
-  }
-  async getFeatures() {
-    throw new Error("getFeatures not supported for tilesets");
-  }
-  async getFormula({
-    column = "*",
-    operation = "count",
-    joinOperation,
-    filters,
-    filterOwner,
-    spatialFilter
-  }) {
-    if (operation === "custom") {
-      throw new Error("Custom aggregation not supported for tilesets");
-    }
-    if (column && column !== "*" || operation !== "count") {
-      assertColumn(this._features, column);
-    }
-    const filteredFeatures = this._getFilteredFeatures(
-      spatialFilter,
-      filters,
-      filterOwner
-    );
-    if (filteredFeatures.length === 0 && operation !== "count") {
-      return { value: null };
-    }
-    const targetOperation = aggregationFunctions[operation];
-    return {
-      value: targetOperation(filteredFeatures, column, joinOperation)
-    };
-  }
-  async getHistogram({
-    operation = "count",
-    ticks,
-    column,
-    joinOperation,
-    filters,
-    filterOwner,
-    spatialFilter
-  }) {
-    const filteredFeatures = this._getFilteredFeatures(
-      spatialFilter,
-      filters,
-      filterOwner
-    );
-    if (!this._features.length) {
-      return [];
-    }
-    assertColumn(this._features, column);
-    return histogram({
-      data: filteredFeatures,
-      valuesColumns: normalizeColumns(column),
-      joinOperation,
-      ticks,
-      operation
-    });
-  }
-  async getCategories({
-    column,
-    operation = "count",
-    operationColumn,
-    joinOperation,
-    filters,
-    filterOwner,
-    spatialFilter
-  }) {
-    const filteredFeatures = this._getFilteredFeatures(
-      spatialFilter,
-      filters,
-      filterOwner
-    );
-    if (!filteredFeatures.length) {
-      return [];
-    }
-    assertColumn(this._features, column, operationColumn);
-    const groups = groupValuesByColumn({
-      data: filteredFeatures,
-      valuesColumns: normalizeColumns(operationColumn || column),
-      joinOperation,
-      keysColumn: column,
-      operation
-    });
-    return groups || [];
-  }
-  async getScatter({
-    xAxisColumn,
-    yAxisColumn,
-    xAxisJoinOperation,
-    yAxisJoinOperation,
-    filters,
-    filterOwner,
-    spatialFilter
-  }) {
-    const filteredFeatures = this._getFilteredFeatures(
-      spatialFilter,
-      filters,
-      filterOwner
-    );
-    if (!filteredFeatures.length) {
-      return [];
-    }
-    assertColumn(this._features, xAxisColumn, yAxisColumn);
-    return scatterPlot({
-      data: filteredFeatures,
-      xAxisColumns: normalizeColumns(xAxisColumn),
-      xAxisJoinOperation,
-      yAxisColumns: normalizeColumns(yAxisColumn),
-      yAxisJoinOperation
-    });
-  }
-  async getTable({
-    columns,
-    searchFilterColumn,
-    searchFilterText,
-    sortBy,
-    sortDirection,
-    sortByColumnType,
-    offset = 0,
-    limit = 10,
-    filters,
-    filterOwner,
-    spatialFilter
-  }) {
-    let filteredFeatures = this._getFilteredFeatures(
-      spatialFilter,
-      filters,
-      filterOwner
-    );
-    if (!filteredFeatures.length) {
-      return { rows: [], totalCount: 0 };
-    }
-    if (searchFilterColumn && searchFilterText) {
-      filteredFeatures = filteredFeatures.filter(
-        (row) => row[searchFilterColumn] && String(row[searchFilterColumn]).toLowerCase().includes(String(searchFilterText).toLowerCase())
-      );
-    }
-    let rows = applySorting(filteredFeatures, {
-      sortBy,
-      sortByDirection: sortDirection,
-      sortByColumnType
-    });
-    const totalCount = rows.length;
-    rows = rows.slice(
-      Math.min(offset, totalCount),
-      Math.min(offset + limit, totalCount)
-    );
-    rows = rows.map((srcRow) => {
-      const dstRow = {};
-      for (const column of columns) {
-        dstRow[column] = srcRow[column];
-      }
-      return dstRow;
-    });
-    return { rows, totalCount };
-  }
-  async getTimeSeries({
-    column,
-    stepSize,
-    operation,
-    operationColumn,
-    joinOperation,
-    filters,
-    filterOwner,
-    spatialFilter
-  }) {
-    const filteredFeatures = this._getFilteredFeatures(
-      spatialFilter,
-      filters,
-      filterOwner
-    );
-    if (!filteredFeatures.length) {
-      return { rows: [] };
-    }
-    assertColumn(this._features, column, operationColumn);
-    const rows = groupValuesByDateColumn({
-      data: filteredFeatures,
-      valuesColumns: normalizeColumns(operationColumn || column),
-      keysColumn: column,
-      groupType: stepSize,
-      operation,
-      joinOperation
-    }) || [];
-    return { rows };
-  }
-  async getRange({
-    column,
-    filters,
-    filterOwner,
-    spatialFilter
-  }) {
-    assertColumn(this._features, column);
-    const filteredFeatures = this._getFilteredFeatures(
-      spatialFilter,
-      filters,
-      filterOwner
-    );
-    if (!this._features.length) {
-      return null;
-    }
-    return {
-      min: aggregationFunctions.min(filteredFeatures, column),
-      max: aggregationFunctions.max(filteredFeatures, column)
-    };
-  }
-  /****************************************************************************
-   * INTERNAL
-   */
-  _getFilteredFeatures(spatialFilter, filters, filterOwner) {
-    assert2(spatialFilter, "spatialFilter required for tilesets");
-    this._extractTileFeatures(spatialFilter);
-    return applyFilters(
-      this._features,
-      getApplicableFilters(filterOwner, filters || this.props.filters),
-      this.props.filtersLogicalOperator || "and"
-    );
-  }
-};
-function assertColumn(features, ...columnArgs) {
-  const columns = Array.from(new Set(columnArgs.map(normalizeColumns).flat()));
-  const featureKeys = Object.keys(features[0]);
-  const invalidColumns = columns.filter(
-    (column) => !featureKeys.includes(column)
-  );
-  if (invalidColumns.length) {
-    throw new InvalidColumnError(
-      `Missing column(s): ${invalidColumns.join(", ")}`
-    );
-  }
-}
-function normalizeColumns(columns) {
-  return Array.isArray(columns) ? columns : typeof columns === "string" ? [columns] : [];
-}
-
-export {
-  __publicField,
-  getClient,
-  setClient,
-  FilterType,
-  ApiVersion,
-  DEFAULT_API_BASE_URL,
-  TileFormat,
-  SpatialIndex,
-  Provider,
-  makeIntervalComplete,
-  filterFunctions,
-  _buildFeatureFilter,
-  applyFilters,
-  buildBinaryFeatureFilter,
-  geojsonFeatures,
-  transformToTileCoords,
-  FEATURE_GEOM_PROPERTY,
-  tileFeaturesGeometries,
-  tileFeaturesSpatialIndex,
-  V3_MINOR_VERSION,
-  DEFAULT_GEO_COLUMN,
-  DEFAULT_MAX_LENGTH_URL,
-  DEFAULT_TILE_RESOLUTION,
-  DEFAULT_AGGREGATION_RES_LEVEL_H3,
-  DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
-  tileFeatures,
-  getApplicableFilters,
-  normalizeObjectKeys,
-  assert2 as assert,
-  InvalidColumnError,
-  isEmptyObject,
-  isPureObject,
-  _getHexagonResolution,
-  WidgetSource,
-  aggregationFunctions,
-  aggregate,
-  applySorting,
-  groupValuesByColumn,
-  groupValuesByDateColumn,
-  histogram,
-  scatterPlot,
-  WidgetTilesetSource
-};