@deck.gl/carto 9.0.0-beta.1 → 9.0.0-beta.10

package/dist/dist.dev.js

@@ -12,7 +12,6 @@ var __exports__ = (() => {
   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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
     get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
   }) : x)(function(x) {
@@ -41,10 +40,6 @@ var __exports__ = (() => {
     mod2
   ));
   var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
-  var __publicField = (obj, key, value) => {
-    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-    return value;
-  };
 
   // external-global-plugin:@deck.gl/core
   var require_core = __commonJS({
@@ -1575,7 +1570,9 @@ var __exports__ = (() => {
           var a = triangles[i] * dim;
           var b = triangles[i + 1] * dim;
           var c = triangles[i + 2] * dim;
-          trianglesArea += Math.abs((data[a] - data[c]) * (data[b + 1] - data[a + 1]) - (data[a] - data[b]) * (data[c + 1] - data[a + 1]));
+          trianglesArea += Math.abs(
+            (data[a] - data[c]) * (data[b + 1] - data[a + 1]) - (data[a] - data[b]) * (data[c + 1] - data[a + 1])
+          );
         }
         return polygonArea === 0 && trianglesArea === 0 ? 0 : Math.abs((trianglesArea - polygonArea) / polygonArea);
       };
@@ -1588,11 +1585,7 @@ var __exports__ = (() => {
         return sum;
       }
       earcut2.flatten = function(data) {
-        var dim = data[0][0].length, result = {
-          vertices: [],
-          holes: [],
-          dimensions: dim
-        }, holeIndex = 0;
+        var dim = data[0][0].length, result = { vertices: [], holes: [], dimensions: dim }, holeIndex = 0;
         for (var i = 0; i < data.length; i++) {
           for (var j = 0; j < data[i].length; j++) {
             for (var d = 0; d < dim; d++)
@@ -9142,18 +9135,13 @@ var __exports__ = (() => {
   });
 
   // src/layers/h3-tile-layer.ts
-  var import_core5 = __toESM(require_core());
-  var import_geo_layers3 = __toESM(require_geo_layers());
+  var import_core5 = __toESM(require_core(), 1);
+  var import_geo_layers3 = __toESM(require_geo_layers(), 1);
 
   // src/layers/h3-tileset-2d.ts
-  var import_geo_layers = __toESM(require_geo_layers());
-  var import_h3_js = __toESM(require_h3_js());
-  function getHexagonsInBoundingBox({
-    west,
-    north,
-    east,
-    south
-  }, resolution) {
+  var import_geo_layers = __toESM(require_geo_layers(), 1);
+  var import_h3_js = __toESM(require_h3_js(), 1);
+  function getHexagonsInBoundingBox({ west, north, east, south }, resolution) {
     const longitudeSpan = Math.abs(east - west);
     if (longitudeSpan > 180) {
       const nSegments = Math.ceil(longitudeSpan / 180);
@@ -9161,17 +9149,26 @@ var __exports__ = (() => {
       for (let s = 0; s < nSegments; s++) {
         const segmentEast = east + s * 180;
         const segmentWest = Math.min(segmentEast + 179.9999999, west);
-        h3Indices2 = h3Indices2.concat(getHexagonsInBoundingBox({
-          west: segmentWest,
-          north,
-          east: segmentEast,
-          south
-        }, resolution));
+        h3Indices2 = h3Indices2.concat(
+          getHexagonsInBoundingBox({ west: segmentWest, north, east: segmentEast, south }, resolution)
+        );
       }
       return [...new Set(h3Indices2)];
     }
     const oversample = 2;
-    const h3Indices = (0, import_h3_js.polygonToCells)([[[west, north], [west, south], [east, south], [east, north], [west, north]]], resolution + oversample, true);
+    const h3Indices = (0, import_h3_js.polygonToCells)(
+      [
+        [
+          [west, north],
+          [west, south],
+          [east, south],
+          [east, north],
+          [west, north]
+        ]
+      ],
+      resolution + oversample,
+      true
+    );
     return oversample ? [...new Set(h3Indices.map((i) => (0, import_h3_js.cellToParent)(i, resolution)))] : h3Indices;
   }
   function tileToBoundingBox(index) {
@@ -9182,12 +9179,7 @@ var __exports__ = (() => {
     const south = Math.min(...latitudes);
     const east = Math.max(...longitudes);
     const north = Math.max(...latitudes);
-    return {
-      west,
-      south,
-      east,
-      north
-    };
+    return { west, south, east, north };
   }
   var BIAS = 2;
   function getHexagonResolution(viewport) {
@@ -9196,11 +9188,7 @@ var __exports__ = (() => {
     return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
   }
   var H3Tileset2D = class extends import_geo_layers._Tileset2D {
-    getTileIndices({
-      viewport,
-      minZoom,
-      maxZoom
-    }) {
+    getTileIndices({ viewport, minZoom, maxZoom }) {
       if (viewport.latitude === void 0)
         return [];
       const [east, south, west, north] = viewport.getBounds();
@@ -9214,45 +9202,28 @@ var __exports__ = (() => {
         const center = (0, import_h3_js.latLngToCell)(viewport.latitude, viewport.longitude, maxZoom);
         indices = (0, import_h3_js.gridDisk)(center, 1);
       } else {
-        indices = getHexagonsInBoundingBox({
-          west,
-          north,
-          east,
-          south
-        }, z);
-      }
-      return indices.map((i) => ({
-        i
-      }));
+        indices = getHexagonsInBoundingBox({ west, north, east, south }, z);
+      }
+      return indices.map((i) => ({ i }));
     }
-    getTileId({
-      i
-    }) {
+    getTileId({ i }) {
       return i;
     }
-    getTileMetadata({
-      i
-    }) {
-      return {
-        bbox: tileToBoundingBox(i)
-      };
+    getTileMetadata({ i }) {
+      return { bbox: tileToBoundingBox(i) };
     }
-    getTileZoom({
-      i
-    }) {
+    getTileZoom({ i }) {
       return (0, import_h3_js.getResolution)(i);
     }
     getParentIndex(index) {
       const resolution = (0, import_h3_js.getResolution)(index.i);
       const i = (0, import_h3_js.cellToParent)(index.i, resolution - 1);
-      return {
-        i
-      };
+      return { i };
     }
   };
 
   // src/layers/spatial-index-tile-layer.ts
-  var import_core2 = __toESM(require_core2());
+  var import_core2 = __toESM(require_core2(), 1);
 
   // src/layers/schema/fast-pbf.ts
   function readPackedTypedArray(TypedArray, pbf, obj) {
@@ -9277,11 +9248,7 @@ var __exports__ = (() => {
   };
   var BandReader = class {
     static read(pbf, end) {
-      return pbf.readFields(BandReader._readField, {
-        name: "",
-        type: "",
-        data: null
-      }, end);
+      return pbf.readFields(BandReader._readField, { name: "", type: "", data: null }, end);
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9300,24 +9267,18 @@ var __exports__ = (() => {
   };
   var TileReader = class {
     static read(pbf, end) {
-      return pbf.readFields(TileReader._readField, {
-        blockWidth: 0,
-        blockHeight: 0,
-        bands: []
-      }, end);
+      return pbf.readFields(TileReader._readField, { blockSize: 0, bands: [] }, end);
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
-        obj.blockWidth = pbf.readVarint();
+        obj.blockSize = pbf.readVarint();
       else if (tag === 2)
-        obj.blockHeight = pbf.readVarint();
-      else if (tag === 3)
         obj.bands.push(BandReader.read(pbf, pbf.readVarint() + pbf.pos));
     }
   };
 
   // src/layers/schema/tile-loader-utils.ts
-  var import_pbf = __toESM(require_pbf());
+  var import_pbf = __toESM(require_pbf(), 1);
   function parsePbf(buffer, TileReader5) {
     const pbf = new import_pbf.default(buffer);
     const tile = TileReader5.read(pbf);
@@ -9325,15 +9286,12 @@ var __exports__ = (() => {
   }
 
   // src/utils.ts
-  var import_core = __toESM(require_core());
+  var import_core = __toESM(require_core(), 1);
   function assert(condition, message) {
     import_core.log.assert(condition, message);
   }
   function createBinaryProxy(data, index) {
-    const {
-      properties,
-      numericProps
-    } = data;
+    const { properties, numericProps } = data;
     return new Proxy(properties[index] || {}, {
       get(target, property) {
         if (property in numericProps) {
@@ -9362,12 +9320,16 @@ var __exports__ = (() => {
       }
       return unknown;
     };
-    scale.copy = () => scaleIdentity().unknown(unknown);
+    scale.copy = () => {
+      const scaleCopy = scaleIdentity();
+      scaleCopy.unknown(unknown);
+      return scaleCopy;
+    };
     return scale;
   }
 
   // src/layers/schema/carto-raster-tile-loader.ts
-  var VERSION = true ? "9.0.0-beta.1" : "latest";
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var id = "cartoRasterTile";
   var DEFAULT_OPTIONS = {
     cartoRasterTile: {
@@ -9390,38 +9352,20 @@ var __exports__ = (() => {
   function parseCartoRasterTile(arrayBuffer, options) {
     if (!arrayBuffer)
       return null;
-    const tile = parsePbf(arrayBuffer, TileReader);
-    const {
-      bands,
-      blockHeight,
-      blockWidth
-    } = tile;
+    const { bands, blockSize } = parsePbf(arrayBuffer, TileReader);
     const numericProps = {};
     for (let i = 0; i < bands.length; i++) {
-      const {
-        name,
-        data
-      } = bands[i];
+      const { name, data } = bands[i];
       numericProps[name] = data;
     }
-    return {
-      blockWidth,
-      blockHeight,
-      cells: {
-        numericProps,
-        properties: []
-      }
-    };
+    return { blockSize, cells: { numericProps, properties: [] } };
   }
   var carto_raster_tile_loader_default = CartoRasterTileLoader;
 
   // src/layers/schema/carto-tile.ts
   var KeyValueObjectReader = class {
     static read(pbf, end) {
-      return pbf.readFields(KeyValueObjectReader._readField, {
-        key: "",
-        value: null
-      }, end);
+      return pbf.readFields(KeyValueObjectReader._readField, { key: "", value: null }, end);
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9436,27 +9380,15 @@ var __exports__ = (() => {
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1) {
-        const {
-          key,
-          value
-        } = KeyValueObjectReader.read(pbf, pbf.readVarint() + pbf.pos);
+        const { key, value } = KeyValueObjectReader.read(pbf, pbf.readVarint() + pbf.pos);
         obj[key] = value;
       }
     }
   };
   var DoublesReader = class {
     static read(pbf, end) {
-      const {
-        value,
-        size
-      } = pbf.readFields(DoublesReader._readField, {
-        value: [],
-        size: 0
-      }, end);
-      return {
-        value: new Float32Array(value),
-        size
-      };
+      const { value, size } = pbf.readFields(DoublesReader._readField, { value: [], size: 0 }, end);
+      return { value: new Float32Array(value), size };
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9467,17 +9399,8 @@ var __exports__ = (() => {
   };
   var IntsReader = class {
     static read(pbf, end) {
-      const {
-        value,
-        size
-      } = pbf.readFields(IntsReader._readField, {
-        value: [],
-        size: 0
-      }, end);
-      return {
-        value: new Uint32Array(value),
-        size
-      };
+      const { value, size } = pbf.readFields(IntsReader._readField, { value: [], size: 0 }, end);
+      return { value: new Uint32Array(value), size };
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9488,9 +9411,7 @@ var __exports__ = (() => {
   };
   var FieldsReader = class {
     static read(pbf, end) {
-      return pbf.readFields(FieldsReader._readField, {
-        id: 0
-      }, end);
+      return pbf.readFields(FieldsReader._readField, { id: 0 }, end);
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9499,9 +9420,7 @@ var __exports__ = (() => {
   };
   var NumericPropReader = class {
     static read(pbf, end) {
-      return pbf.readFields(NumericPropReader._readField, {
-        value: []
-      }, end);
+      return pbf.readFields(NumericPropReader._readField, { value: [] }, end);
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9510,10 +9429,7 @@ var __exports__ = (() => {
   };
   var NumericPropKeyValueReader = class {
     static read(pbf, end) {
-      return pbf.readFields(NumericPropKeyValueReader._readField, {
-        key: "",
-        value: null
-      }, end);
+      return pbf.readFields(NumericPropKeyValueReader._readField, { key: "", value: null }, end);
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9524,14 +9440,18 @@ var __exports__ = (() => {
   };
   var PointsReader = class {
     static read(pbf, end) {
-      return pbf.readFields(PointsReader._readField, {
-        positions: null,
-        globalFeatureIds: null,
-        featureIds: null,
-        properties: [],
-        numericProps: {},
-        fields: []
-      }, end);
+      return pbf.readFields(
+        PointsReader._readField,
+        {
+          positions: null,
+          globalFeatureIds: null,
+          featureIds: null,
+          properties: [],
+          numericProps: {},
+          fields: []
+        },
+        end
+      );
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9551,15 +9471,19 @@ var __exports__ = (() => {
   };
   var LinesReader = class {
     static read(pbf, end) {
-      return pbf.readFields(LinesReader._readField, {
-        positions: null,
-        pathIndices: null,
-        globalFeatureIds: null,
-        featureIds: null,
-        properties: [],
-        numericProps: {},
-        fields: []
-      }, end);
+      return pbf.readFields(
+        LinesReader._readField,
+        {
+          positions: null,
+          pathIndices: null,
+          globalFeatureIds: null,
+          featureIds: null,
+          properties: [],
+          numericProps: {},
+          fields: []
+        },
+        end
+      );
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9581,17 +9505,21 @@ var __exports__ = (() => {
   };
   var PolygonsReader = class {
     static read(pbf, end) {
-      return pbf.readFields(PolygonsReader._readField, {
-        positions: null,
-        polygonIndices: null,
-        globalFeatureIds: null,
-        featureIds: null,
-        primitivePolygonIndices: null,
-        triangles: null,
-        properties: [],
-        numericProps: {},
-        fields: []
-      }, end);
+      return pbf.readFields(
+        PolygonsReader._readField,
+        {
+          positions: null,
+          polygonIndices: null,
+          globalFeatureIds: null,
+          featureIds: null,
+          primitivePolygonIndices: null,
+          triangles: null,
+          properties: [],
+          numericProps: {},
+          fields: []
+        },
+        end
+      );
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9617,11 +9545,7 @@ var __exports__ = (() => {
   };
   var TileReader2 = class {
     static read(pbf, end) {
-      return pbf.readFields(TileReader2._readField, {
-        points: null,
-        lines: null,
-        polygons: null
-      }, end);
+      return pbf.readFields(TileReader2._readField, { points: null, lines: null, polygons: null }, end);
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9636,9 +9560,7 @@ var __exports__ = (() => {
   // src/layers/schema/carto-spatial-tile.ts
   var IndicesReader = class {
     static read(pbf, end) {
-      return pbf.readFields(IndicesReader._readField, {
-        value: []
-      }, end);
+      return pbf.readFields(IndicesReader._readField, { value: [] }, end);
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9647,11 +9569,11 @@ var __exports__ = (() => {
   };
   var CellsReader = class {
     static read(pbf, end) {
-      return pbf.readFields(CellsReader._readField, {
-        indices: null,
-        properties: [],
-        numericProps: {}
-      }, end);
+      return pbf.readFields(
+        CellsReader._readField,
+        { indices: null, properties: [], numericProps: {} },
+        end
+      );
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9666,10 +9588,7 @@ var __exports__ = (() => {
   };
   var TileReader3 = class {
     static read(pbf, end) {
-      return pbf.readFields(TileReader3._readField, {
-        scheme: 0,
-        cells: null
-      }, end);
+      return pbf.readFields(TileReader3._readField, { scheme: 0, cells: null }, end);
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -9680,7 +9599,7 @@ var __exports__ = (() => {
   };
 
   // ../../node_modules/quadbin/dist/esm/index.js
-  var import_tile_cover = __toESM(require_tile_cover());
+  var import_tile_cover = __toESM(require_tile_cover(), 1);
   var B = [
     0x5555555555555555n,
     0x3333333333333333n,
@@ -9743,30 +9662,22 @@ var __exports__ = (() => {
 
   // src/layers/schema/spatialjson-utils.ts
   function binaryToSpatialjson(binary) {
-    const {
-      cells,
-      scheme
-    } = binary;
+    const { cells, scheme } = binary;
     const count = cells.indices.value.length;
     const spatial = [];
     for (let i = 0; i < count; i++) {
       const id4 = scheme === "h3" ? bigIntToHex(cells.indices.value[i]) : cells.indices.value[i];
-      const properties = {
-        ...cells.properties[i]
-      };
+      const properties = { ...cells.properties[i] };
       for (const key of Object.keys(cells.numericProps)) {
         properties[key] = cells.numericProps[key].value[i];
       }
-      spatial.push({
-        id: id4,
-        properties
-      });
+      spatial.push({ id: id4, properties });
     }
     return spatial;
   }
 
   // src/layers/schema/carto-spatial-tile-loader.ts
-  var VERSION2 = true ? "9.0.0-beta.1" : "latest";
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var id2 = "cartoSpatialTile";
   var DEFAULT_OPTIONS2 = {
     cartoSpatialTile: {
@@ -9791,39 +9702,40 @@ var __exports__ = (() => {
     if (!arrayBuffer)
       return null;
     const tile = parsePbf(arrayBuffer, TileReader3);
-    const {
-      cells
-    } = tile;
+    const { cells } = tile;
     const scheme = options?.cartoSpatialTile?.scheme;
-    const data = {
-      cells,
-      scheme
-    };
+    const data = { cells, scheme };
     return binaryToSpatialjson(data);
   }
   var carto_spatial_tile_loader_default = CartoSpatialTileLoader;
 
   // src/layers/spatial-index-tile-layer.ts
-  var import_geo_layers2 = __toESM(require_geo_layers());
+  var import_geo_layers2 = __toESM(require_geo_layers(), 1);
+
+  // src/constants.ts
+  var DEFAULT_TILE_SIZE = 512;
+  var DEFAULT_TILE_RESOLUTION = 0.5;
+  var DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
+  var DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
+
+  // src/layers/spatial-index-tile-layer.ts
   (0, import_core2.registerLoaders)([carto_raster_tile_loader_default, carto_spatial_tile_loader_default]);
   function isFeatureIdDefined(value) {
     return value !== void 0 && value !== null && value !== "";
   }
-  var defaultProps = {};
+  var defaultProps = {
+    tileSize: DEFAULT_TILE_SIZE
+  };
   var SpatialIndexTileLayer = class extends import_geo_layers2.TileLayer {
     _updateAutoHighlight(info) {
-      const {
-        hoveredFeatureId
-      } = this.state;
+      const { hoveredFeatureId } = this.state;
       const hoveredFeature = info.object;
-      let newHoveredFeatureId;
+      let newHoveredFeatureId = null;
       if (hoveredFeature) {
         newHoveredFeatureId = hoveredFeature.id;
       }
       if (hoveredFeatureId !== newHoveredFeatureId) {
-        let {
-          highlightColor
-        } = this.props;
+        let { highlightColor } = this.props;
         if (typeof highlightColor === "function") {
           highlightColor = highlightColor(info);
         }
@@ -9840,9 +9752,7 @@ var __exports__ = (() => {
       };
     }
     getHighlightedObjectIndex(tile) {
-      const {
-        hoveredFeatureId
-      } = this.state;
+      const { hoveredFeatureId } = this.state;
       const data = tile.content;
       const isFeatureIdPresent = isFeatureIdDefined(hoveredFeatureId);
       if (!isFeatureIdPresent || !Array.isArray(data) || !this._featureInTile(tile, hoveredFeatureId)) {
@@ -9854,9 +9764,7 @@ var __exports__ = (() => {
       const tileset = this.state.tileset;
       const tileZoom = tileset.getTileZoom(tile.index);
       const KEY = tile.index.q ? "q" : "i";
-      let featureIndex = {
-        [KEY]: featureId
-      };
+      let featureIndex = { [KEY]: featureId };
       let featureZoom = tileset.getTileZoom(featureIndex);
       while (!(featureZoom <= tileZoom)) {
         featureIndex = tileset.getParentIndex(featureIndex);
@@ -9865,29 +9773,23 @@ var __exports__ = (() => {
       return featureIndex[KEY] === tile.index[KEY];
     }
   };
-  __publicField(SpatialIndexTileLayer, "layerName", "SpatialIndexTileLayer");
-  __publicField(SpatialIndexTileLayer, "defaultProps", defaultProps);
+  SpatialIndexTileLayer.layerName = "SpatialIndexTileLayer";
+  SpatialIndexTileLayer.defaultProps = defaultProps;
 
   // src/layers/utils.ts
-  var import_core3 = __toESM(require_core());
-  var import_core4 = __toESM(require_core());
+  var import_core3 = __toESM(require_core(), 1);
+  var import_core4 = __toESM(require_core(), 1);
   function injectAccessToken(loadOptions, accessToken) {
     if (!loadOptions?.fetch?.headers?.Authorization) {
       loadOptions.fetch = {
         ...loadOptions.fetch,
-        headers: {
-          ...loadOptions.fetch?.headers,
-          Authorization: `Bearer ${accessToken}`
-        }
+        headers: { ...loadOptions.fetch?.headers, Authorization: `Bearer ${accessToken}` }
       };
     }
   }
   function mergeBoundaryData(geometry, properties) {
     const mapping = {};
-    for (const {
-      geoid,
-      ...rest
-    } of properties.properties) {
+    for (const { geoid, ...rest } of properties.properties) {
       if (geoid in mapping) {
         import_core3.log.warn("Duplicate geoid key in boundary mapping, using first occurance")();
       } else {
@@ -9899,13 +9801,8 @@ var __exports__ = (() => {
       if (geom.positions.value.length === 0) {
         continue;
       }
-      geom.properties = geom.properties.map(({
-        geoid
-      }) => mapping[geoid]);
-      const {
-        positions,
-        globalFeatureIds
-      } = geom;
+      geom.properties = geom.properties.map(({ geoid }) => mapping[geoid]);
+      const { positions, globalFeatureIds } = geom;
       let indices = null;
       if (type === "lines")
         indices = geom.pathIndices.value;
@@ -9916,10 +9813,7 @@ var __exports__ = (() => {
         const sourceProp = properties.numericProps[key].value;
         const TypedArray = sourceProp.constructor;
         const destProp = new TypedArray(length);
-        geom.numericProps[key] = {
-          value: destProp,
-          size: 1
-        };
+        geom.numericProps[key] = { value: destProp, size: 1 };
         if (!indices) {
           for (let i = 0; i < length; i++) {
             const featureId = globalFeatureIds.value[i];
@@ -9949,12 +9843,8 @@ var __exports__ = (() => {
 
   // src/layers/h3-tile-layer.ts
   var renderSubLayers = (props) => {
-    const {
-      data
-    } = props;
-    const {
-      index
-    } = props.tile;
+    const { data } = props;
+    const { index } = props.tile;
     if (!data || !data.length)
       return null;
     return new import_geo_layers3.H3HexagonLayer(props, {
@@ -9964,7 +9854,8 @@ var __exports__ = (() => {
     });
   };
   var defaultProps2 = {
-    data: TilejsonPropType
+    data: TilejsonPropType,
+    tileSize: DEFAULT_TILE_SIZE
   };
   var H3TileLayer = class extends import_core5.CompositeLayer {
     initializeState() {
@@ -9974,71 +9865,62 @@ var __exports__ = (() => {
       const loadOptions = super.getLoadOptions() || {};
       const tileJSON = this.props.data;
       injectAccessToken(loadOptions, tileJSON.accessToken);
-      loadOptions.cartoSpatialTile = {
-        ...loadOptions.cartoSpatialTile,
-        scheme: "h3"
-      };
+      loadOptions.cartoSpatialTile = { ...loadOptions.cartoSpatialTile, scheme: "h3" };
       return loadOptions;
     }
     renderLayers() {
       const tileJSON = this.props.data;
       if (!tileJSON)
         return null;
-      const {
-        tiles: data
-      } = tileJSON;
-      let {
-        minresolution,
-        maxresolution
-      } = tileJSON;
+      const { tiles: data } = tileJSON;
+      let { minresolution, maxresolution } = tileJSON;
       if (this.props.minZoom) {
-        minresolution = Math.max(minresolution, getHexagonResolution({
-          zoom: this.props.minZoom,
-          latitude: 0
-        }));
+        minresolution = Math.max(
+          minresolution,
+          getHexagonResolution({ zoom: this.props.minZoom, latitude: 0 })
+        );
       }
       if (this.props.maxZoom) {
-        maxresolution = Math.min(maxresolution, getHexagonResolution({
-          zoom: this.props.maxZoom,
-          latitude: 0
-        }));
+        maxresolution = Math.min(
+          maxresolution,
+          getHexagonResolution({ zoom: this.props.maxZoom, latitude: 0 })
+        );
       }
-      return [new SpatialIndexTileLayer(this.props, {
-        id: `h3-tile-layer-${this.props.id}`,
-        data,
-        TilesetClass: H3Tileset2D,
-        renderSubLayers,
-        minZoom: minresolution,
-        maxZoom: maxresolution,
-        loadOptions: this.getLoadOptions()
-      })];
+      return [
+        new SpatialIndexTileLayer(this.props, {
+          id: `h3-tile-layer-${this.props.id}`,
+          data,
+          TilesetClass: H3Tileset2D,
+          renderSubLayers,
+          minZoom: minresolution,
+          maxZoom: maxresolution,
+          loadOptions: this.getLoadOptions()
+        })
+      ];
     }
   };
-  __publicField(H3TileLayer, "layerName", "H3TileLayer");
-  __publicField(H3TileLayer, "defaultProps", defaultProps2);
+  H3TileLayer.layerName = "H3TileLayer";
+  H3TileLayer.defaultProps = defaultProps2;
 
   // src/layers/point-label-layer.ts
-  var import_core6 = __toESM(require_core());
-  var import_layers = __toESM(require_layers());
+  var import_core6 = __toESM(require_core(), 1);
+  var import_layers = __toESM(require_layers(), 1);
   var [LEFT, TOP, RIGHT, BOTTOM] = [0, 1, 2, 3];
   var EnhancedTextBackgroundLayer = class extends import_layers._TextBackgroundLayer {
     getShaders() {
       const shaders = super.getShaders();
       let vs = shaders.vs;
       vs = vs.replaceAll("padding.", "_padding.");
-      vs = vs.replace("void main(void) {", "void main(void) {\n  vec4 _padding = padding + instancePixelOffsets.xyxy * vec4(1.0, 1.0, -1.0, -1.0);");
-      return {
-        ...shaders,
-        vs
-      };
+      vs = vs.replace(
+        "void main(void) {",
+        "void main(void) {\n  vec4 _padding = padding + instancePixelOffsets.xyxy * vec4(1.0, 1.0, -1.0, -1.0);"
+      );
+      return { ...shaders, vs };
     }
   };
-  __publicField(EnhancedTextBackgroundLayer, "layerName", "EnhancedTextBackgroundLayer");
+  EnhancedTextBackgroundLayer.layerName = "EnhancedTextBackgroundLayer";
   var EnhancedTextLayer = class extends import_layers.TextLayer {
-    filterSubLayer({
-      layer,
-      renderPass
-    }) {
+    filterSubLayer({ layer, renderPass }) {
       const background = layer.id.includes("primary-background");
       if (renderPass === "collision") {
         return background;
@@ -10046,18 +9928,11 @@ var __exports__ = (() => {
       return !background;
     }
   };
-  __publicField(EnhancedTextLayer, "layerName", "EnhancedTextLayer");
+  EnhancedTextLayer.layerName = "EnhancedTextLayer";
   var defaultProps3 = {
     ...import_layers.TextLayer.defaultProps,
-    getRadius: {
-      type: "accessor",
-      value: 1
-    },
-    radiusScale: {
-      type: "number",
-      min: 0,
-      value: 1
-    }
+    getRadius: { type: "accessor", value: 1 },
+    radiusScale: { type: "number", min: 0, value: 1 }
   };
   var PointLabelLayer = class extends import_core6.CompositeLayer {
     calculatePixelOffset(secondary) {
@@ -10085,14 +9960,13 @@ var __exports__ = (() => {
       return typeof getRadius === "function" ? (d, info) => {
         const r = (info ? getRadius(d, info) : 1) * radiusScale * radiusPadding;
         return [xMult * (r + xPadding), yMult * (r + yPadding) + yOffset];
-      } : [xMult * (getRadius * radiusScale * radiusPadding + xPadding), yMult * (getRadius * radiusScale * radiusPadding + yPadding) + yOffset];
+      } : [
+        xMult * (getRadius * radiusScale * radiusPadding + xPadding),
+        yMult * (getRadius * radiusScale * radiusPadding + yPadding) + yOffset
+      ];
     }
     calculateBackgroundPadding() {
-      const {
-        getTextAnchor: anchor,
-        getAlignmentBaseline: alignment,
-        sizeScale
-      } = this.props;
+      const { getTextAnchor: anchor, getAlignmentBaseline: alignment, sizeScale } = this.props;
       const paddingX = 12 * sizeScale;
       const paddingY = 3 * sizeScale;
       const backgroundPadding = [0, 0, 0, 0];
@@ -10114,10 +9988,7 @@ var __exports__ = (() => {
       }
       return backgroundPadding;
     }
-    renderTextLayer(id4, {
-      updateTriggers: updateTriggersOverride = {},
-      ...props
-    }) {
+    renderTextLayer(id4, { updateTriggers: updateTriggersOverride = {}, ...props }) {
       const {
         data,
         characterSet,
@@ -10134,33 +10005,39 @@ var __exports__ = (() => {
         getTextAnchor,
         updateTriggers
       } = this.props;
-      return new EnhancedTextLayer(this.getSubLayerProps({
-        id: id4,
-        data,
-        characterSet,
-        fontFamily,
-        fontSettings,
-        fontWeight,
-        outlineColor,
-        outlineWidth,
-        sizeScale,
-        getAlignmentBaseline,
-        getColor,
-        getPosition,
-        getTextAnchor,
-        updateTriggers: {
-          ...updateTriggers,
-          ...updateTriggersOverride,
-          getPixelOffset: [updateTriggers.getRadius, updateTriggers.getTextAnchor, updateTriggers.getAlignmentBaseline, radiusScale, sizeScale]
-        }
-      }), {
-        getSize: 1,
-        _subLayerProps: {
-          background: {
-            type: EnhancedTextBackgroundLayer
+      return new EnhancedTextLayer(
+        this.getSubLayerProps({
+          id: id4,
+          data,
+          characterSet,
+          fontFamily,
+          fontSettings,
+          fontWeight,
+          outlineColor,
+          outlineWidth,
+          sizeScale,
+          getAlignmentBaseline,
+          getColor,
+          getPosition,
+          getTextAnchor,
+          updateTriggers: {
+            ...updateTriggers,
+            ...updateTriggersOverride,
+            getPixelOffset: [
+              updateTriggers.getRadius,
+              updateTriggers.getTextAnchor,
+              updateTriggers.getAlignmentBaseline,
+              radiusScale,
+              sizeScale
+            ]
           }
-        }
-      }, props);
+        }),
+        {
+          getSize: 1,
+          _subLayerProps: { background: { type: EnhancedTextBackgroundLayer } }
+        },
+        props
+      );
     }
     renderLayers() {
       const {
@@ -10173,36 +10050,33 @@ var __exports__ = (() => {
       } = this.props;
       const getPixelOffset = this.calculatePixelOffset(false);
       const backgroundPadding = this.calculateBackgroundPadding();
-      const out = [this.renderTextLayer(`${updateTriggers.getText}-primary`, {
-        backgroundPadding,
-        getText,
-        getPixelOffset,
-        background: true
-      }), Boolean(getSecondaryText) && this.renderTextLayer(`${updateTriggers.getSecondaryText}-secondary`, {
-        getText: getSecondaryText,
-        getPixelOffset: this.calculatePixelOffset(true),
-        getAlignmentBaseline: "top",
-        ...getSecondaryColor && {
-          getColor: getSecondaryColor
-        },
-        ...secondarySizeScale && {
-          sizeScale: secondarySizeScale
-        },
-        ...secondaryOutlineColor && {
-          outlineColor: secondaryOutlineColor
-        }
-      })];
+      const out = [
+        this.renderTextLayer(`${updateTriggers.getText}-primary`, {
+          backgroundPadding,
+          getText,
+          getPixelOffset,
+          background: true
+        }),
+        Boolean(getSecondaryText) && this.renderTextLayer(`${updateTriggers.getSecondaryText}-secondary`, {
+          getText: getSecondaryText,
+          getPixelOffset: this.calculatePixelOffset(true),
+          getAlignmentBaseline: "top",
+          ...getSecondaryColor && { getColor: getSecondaryColor },
+          ...secondarySizeScale && { sizeScale: secondarySizeScale },
+          ...secondaryOutlineColor && { outlineColor: secondaryOutlineColor }
+        })
+      ];
       return out;
     }
   };
-  __publicField(PointLabelLayer, "layerName", "PointLabelLayer");
-  __publicField(PointLabelLayer, "defaultProps", defaultProps3);
+  PointLabelLayer.layerName = "PointLabelLayer";
+  PointLabelLayer.defaultProps = defaultProps3;
 
   // src/layers/quadbin-tile-layer.ts
-  var import_core7 = __toESM(require_core());
+  var import_core7 = __toESM(require_core(), 1);
 
   // src/layers/quadbin-layer.ts
-  var import_geo_layers4 = __toESM(require_geo_layers());
+  var import_geo_layers4 = __toESM(require_geo_layers(), 1);
 
   // ../../node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js
   var PI = Math.PI;
@@ -10223,17 +10097,16 @@ var __exports__ = (() => {
   // src/layers/quadbin-utils.ts
   var TILE_SIZE2 = 512;
   function quadbinToOffset(quadbin) {
-    const {
-      x,
-      y,
-      z
-    } = cellToTile(quadbin);
+    const { x, y, z } = cellToTile(quadbin);
     const scale = TILE_SIZE2 / (1 << z);
     return [x * scale, TILE_SIZE2 - y * scale, scale];
   }
   function quadbinToWorldBounds(quadbin, coverage) {
     const [xOffset, yOffset, scale] = quadbinToOffset(quadbin);
-    return [[xOffset, yOffset], [xOffset + coverage * scale, yOffset - coverage * scale]];
+    return [
+      [xOffset, yOffset],
+      [xOffset + coverage * scale, yOffset - coverage * scale]
+    ];
   }
   function getQuadbinPolygon(quadbin, coverage = 1) {
     const [topLeft, bottomRight] = quadbinToWorldBounds(quadbin, coverage);
@@ -10244,72 +10117,47 @@ var __exports__ = (() => {
 
   // src/layers/quadbin-layer.ts
   var defaultProps4 = {
-    getQuadbin: {
-      type: "accessor",
-      value: (d) => d.quadbin
-    }
+    getQuadbin: { type: "accessor", value: (d) => d.quadbin }
   };
   var QuadbinLayer = class extends import_geo_layers4._GeoCellLayer {
     indexToBounds() {
-      const {
-        data,
-        extruded,
-        getQuadbin
-      } = this.props;
+      const { data, extruded, getQuadbin } = this.props;
       const coverage = extruded ? 0.99 : 1;
       return {
         data,
         _normalize: false,
         positionFormat: "XY",
         getPolygon: (x, objectInfo) => getQuadbinPolygon(getQuadbin(x, objectInfo), coverage),
-        updateTriggers: {
-          getPolygon: coverage
-        }
+        updateTriggers: { getPolygon: coverage }
       };
     }
   };
-  __publicField(QuadbinLayer, "layerName", "QuadbinLayer");
-  __publicField(QuadbinLayer, "defaultProps", defaultProps4);
+  QuadbinLayer.layerName = "QuadbinLayer";
+  QuadbinLayer.defaultProps = defaultProps4;
 
   // src/layers/quadbin-tileset-2d.ts
-  var import_geo_layers5 = __toESM(require_geo_layers());
+  var import_geo_layers5 = __toESM(require_geo_layers(), 1);
   var QuadbinTileset2D = class extends import_geo_layers5._Tileset2D {
     getTileIndices(opts) {
-      return super.getTileIndices(opts).map(tileToCell).map((q) => ({
-        q,
-        i: bigIntToHex(q)
-      }));
+      return super.getTileIndices(opts).map(tileToCell).map((q) => ({ q, i: bigIntToHex(q) }));
     }
-    getTileId({
-      q,
-      i
-    }) {
+    getTileId({ q, i }) {
       return i || bigIntToHex(q);
     }
-    getTileMetadata({
-      q
-    }) {
+    getTileMetadata({ q }) {
       return super.getTileMetadata(cellToTile(q));
     }
-    getTileZoom({
-      q
-    }) {
+    getTileZoom({ q }) {
       return Number(getResolution2(q));
     }
-    getParentIndex({
-      q
-    }) {
-      return {
-        q: cellToParent2(q)
-      };
+    getParentIndex({ q }) {
+      return { q: cellToParent2(q) };
     }
   };
 
   // src/layers/quadbin-tile-layer.ts
   var renderSubLayers2 = (props) => {
-    const {
-      data
-    } = props;
+    const { data } = props;
     if (!data || !data.length)
       return null;
     const isBigInt = typeof data[0].id === "bigint";
@@ -10318,46 +10166,43 @@ var __exports__ = (() => {
     });
   };
   var defaultProps5 = {
-    data: TilejsonPropType
+    data: TilejsonPropType,
+    tileSize: DEFAULT_TILE_SIZE
   };
   var QuadbinTileLayer = class extends import_core7.CompositeLayer {
     getLoadOptions() {
       const loadOptions = super.getLoadOptions() || {};
       const tileJSON = this.props.data;
       injectAccessToken(loadOptions, tileJSON.accessToken);
-      loadOptions.cartoSpatialTile = {
-        ...loadOptions.cartoSpatialTile,
-        scheme: "quadbin"
-      };
+      loadOptions.cartoSpatialTile = { ...loadOptions.cartoSpatialTile, scheme: "quadbin" };
       return loadOptions;
     }
     renderLayers() {
       const tileJSON = this.props.data;
       if (!tileJSON)
         return null;
-      const {
-        tiles: data,
-        maxresolution: maxZoom
-      } = tileJSON;
-      return [new SpatialIndexTileLayer(this.props, {
-        id: `quadbin-tile-layer-${this.props.id}`,
-        data,
-        TilesetClass: QuadbinTileset2D,
-        renderSubLayers: renderSubLayers2,
-        maxZoom,
-        loadOptions: this.getLoadOptions()
-      })];
+      const { tiles: data, maxresolution: maxZoom } = tileJSON;
+      return [
+        new SpatialIndexTileLayer(this.props, {
+          id: `quadbin-tile-layer-${this.props.id}`,
+          data,
+          TilesetClass: QuadbinTileset2D,
+          renderSubLayers: renderSubLayers2,
+          maxZoom,
+          loadOptions: this.getLoadOptions()
+        })
+      ];
     }
   };
-  __publicField(QuadbinTileLayer, "layerName", "QuadbinTileLayer");
-  __publicField(QuadbinTileLayer, "defaultProps", defaultProps5);
+  QuadbinTileLayer.layerName = "QuadbinTileLayer";
+  QuadbinTileLayer.defaultProps = defaultProps5;
 
   // src/layers/raster-tile-layer.ts
-  var import_core9 = __toESM(require_core());
+  var import_core9 = __toESM(require_core(), 1);
 
   // src/layers/raster-layer.ts
-  var import_core8 = __toESM(require_core());
-  var import_layers2 = __toESM(require_layers());
+  var import_core8 = __toESM(require_core(), 1);
+  var import_layers2 = __toESM(require_layers(), 1);
 
   // src/layers/raster-layer-vertex.glsl.ts
   var raster_layer_vertex_glsl_default = `#version 300 es
@@ -10393,8 +10238,8 @@ void main(void) {
   vec2 common_position = offset.xy;
   float scale = offset.z;
 
-  int yIndex = - (gl_InstanceID / 256);
-  int xIndex = gl_InstanceID + (yIndex * 256);
+  int yIndex = - (gl_InstanceID / BLOCK_WIDTH);
+  int xIndex = gl_InstanceID + (yIndex * BLOCK_WIDTH);
   common_position += scale * vec2(float(xIndex), float(yIndex));
 
   vec4 color = isStroke ? instanceLineColors : instanceFillColors;
@@ -10463,15 +10308,19 @@ void main(void) {
     ...import_layers2.ColumnLayer.defaultProps,
     extruded: false,
     diskResolution: 4,
-    vertices: [[-0.5, -0.5], [0.5, -0.5], [0.5, 0.5], [-0.5, 0.5]]
+    vertices: [
+      [-0.5, -0.5],
+      [0.5, -0.5],
+      [0.5, 0.5],
+      [-0.5, 0.5]
+    ]
   };
   var RasterColumnLayer = class extends import_layers2.ColumnLayer {
     getShaders() {
       const shaders = super.getShaders();
-      return {
-        ...shaders,
-        vs: raster_layer_vertex_glsl_default
-      };
+      const data = this.props.data;
+      const BLOCK_WIDTH = data.data.blockSize ?? Math.sqrt(data.length);
+      return { ...shaders, defines: { ...shaders.defines, BLOCK_WIDTH }, vs: raster_layer_vertex_glsl_default };
     }
     initializeState() {
       const attributeManager = this.getAttributeManager();
@@ -10483,16 +10332,14 @@ void main(void) {
         },
         instanceFillColors: {
           size: this.props.colorFormat.length,
-          type: 5121,
-          normalized: true,
+          type: "unorm8",
           transition: true,
           accessor: "getFillColor",
           defaultValue: [0, 0, 0, 255]
         },
         instanceLineColors: {
           size: this.props.colorFormat.length,
-          type: 5121,
-          normalized: true,
+          type: "unorm8",
           transition: true,
           accessor: "getLineColor",
           defaultValue: [255, 255, 255, 255]
@@ -10500,7 +10347,7 @@ void main(void) {
       });
     }
   };
-  __publicField(RasterColumnLayer, "layerName", "RasterColumnLayer");
+  RasterColumnLayer.layerName = "RasterColumnLayer";
   var RasterLayer = class extends import_core8.CompositeLayer {
     renderLayers() {
       const {
@@ -10514,60 +10361,54 @@ void main(void) {
       } = this.props;
       if (!data || !tileIndex)
         return null;
-      const {
-        blockWidth,
-        blockHeight
-      } = data;
-      assert(blockWidth === blockHeight, `blockWidth (${blockWidth}) must equal blockHeight (${blockHeight})`);
+      const blockSize = data.blockSize ?? 0;
       const [xOffset, yOffset, scale] = quadbinToOffset(tileIndex);
-      const offset = [xOffset, yOffset, scale / blockWidth];
+      const offset = [xOffset, yOffset, scale / blockSize];
       const CellLayer = this.getSubLayerClass("column", RasterColumnLayer);
-      return new CellLayer(this.props, this.getSubLayerProps({
-        id: "cell",
-        updateTriggers,
-        getElevation: this.getSubLayerAccessor(getElevation),
-        getFillColor: this.getSubLayerAccessor(getFillColor),
-        getLineColor: this.getSubLayerAccessor(getLineColor),
-        getLineWidth: this.getSubLayerAccessor(getLineWidth)
-      }), {
-        data: {
-          data,
-          length: blockWidth * blockHeight
-        },
-        offset
-      });
+      return new CellLayer(
+        this.props,
+        this.getSubLayerProps({
+          id: "cell",
+          updateTriggers,
+          getElevation: this.getSubLayerAccessor(getElevation),
+          getFillColor: this.getSubLayerAccessor(getFillColor),
+          getLineColor: this.getSubLayerAccessor(getLineColor),
+          getLineWidth: this.getSubLayerAccessor(getLineWidth)
+        }),
+        {
+          data: {
+            data,
+            length: blockSize * blockSize
+          },
+          offset
+        }
+      );
     }
     getSubLayerAccessor(accessor) {
       if (typeof accessor !== "function") {
         return super.getSubLayerAccessor(accessor);
       }
       return (object, info) => {
-        const {
-          data,
-          index
-        } = info;
+        const { data, index } = info;
         const binaryData = data.data;
         const proxy = createBinaryProxy(binaryData.cells, index);
-        return accessor({
-          properties: proxy
-        }, info);
+        return accessor({ properties: proxy }, info);
       };
     }
   };
-  __publicField(RasterLayer, "layerName", "RasterLayer");
-  __publicField(RasterLayer, "defaultProps", defaultProps6);
+  RasterLayer.layerName = "RasterLayer";
+  RasterLayer.defaultProps = defaultProps6;
 
   // src/layers/raster-tile-layer.ts
   var renderSubLayers3 = (props) => {
     const tileIndex = props.tile?.index?.q;
     if (!tileIndex)
       return null;
-    return new RasterLayer(props, {
-      tileIndex
-    });
+    return new RasterLayer(props, { tileIndex });
   };
   var defaultProps7 = {
-    data: TilejsonPropType
+    data: TilejsonPropType,
+    tileSize: DEFAULT_TILE_SIZE
   };
   var RasterTileLayer = class extends import_core9.CompositeLayer {
     getLoadOptions() {
@@ -10580,35 +10421,30 @@ void main(void) {
       const tileJSON = this.props.data;
       if (!tileJSON)
         return null;
-      const {
-        tiles: data,
-        minzoom: minZoom,
-        maxzoom: maxZoom
-      } = tileJSON;
-      return [new SpatialIndexTileLayer(this.props, {
-        id: `raster-tile-layer-${this.props.id}`,
-        data,
-        TilesetClass: QuadbinTileset2D,
-        renderSubLayers: renderSubLayers3,
-        minZoom,
-        maxZoom,
-        loadOptions: this.getLoadOptions()
-      })];
+      const { tiles: data, minzoom: minZoom, maxzoom: maxZoom } = tileJSON;
+      return [
+        new SpatialIndexTileLayer(this.props, {
+          id: `raster-tile-layer-${this.props.id}`,
+          data,
+          TilesetClass: QuadbinTileset2D,
+          renderSubLayers: renderSubLayers3,
+          minZoom,
+          maxZoom,
+          loadOptions: this.getLoadOptions()
+        })
+      ];
     }
   };
-  __publicField(RasterTileLayer, "layerName", "RasterTileLayer");
-  __publicField(RasterTileLayer, "defaultProps", defaultProps7);
+  RasterTileLayer.layerName = "RasterTileLayer";
+  RasterTileLayer.defaultProps = defaultProps7;
 
   // src/layers/vector-tile-layer.ts
-  var import_core10 = __toESM(require_core2());
+  var import_core10 = __toESM(require_core2(), 1);
 
   // src/layers/schema/carto-properties-tile.ts
   var TileReader4 = class {
     static read(pbf, end) {
-      return pbf.readFields(TileReader4._readField, {
-        properties: [],
-        numericProps: {}
-      }, end);
+      return pbf.readFields(TileReader4._readField, { properties: [], numericProps: {} }, end);
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
@@ -10642,8 +10478,8 @@ void main(void) {
   var carto_properties_tile_loader_default = CartoPropertiesTileLoader;
 
   // src/layers/schema/carto-vector-tile-loader.ts
-  var import_earcut = __toESM(require_earcut());
-  var VERSION3 = true ? "9.0.0-beta.1" : "latest";
+  var import_earcut = __toESM(require_earcut(), 1);
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var id3 = "cartoVectorTile";
   var DEFAULT_OPTIONS3 = {
     cartoVectorTile: {
@@ -10679,10 +10515,7 @@ void main(void) {
     }
   }
   function triangulate(polygons) {
-    const {
-      polygonIndices,
-      primitivePolygonIndices
-    } = polygons;
+    const { polygonIndices, primitivePolygonIndices } = polygons;
     const triangles = [];
     let rangeStart = 0;
     for (let i = 0; i < polygonIndices.value.length - 1; i++) {
@@ -10691,16 +10524,9 @@ void main(void) {
       const rangeEnd = primitivePolygonIndices.value.indexOf(endPosition);
       const indices = primitivePolygonIndices.value.subarray(rangeStart, rangeEnd);
       rangeStart = rangeEnd;
-      triangulatePolygon(polygons, triangles, {
-        startPosition,
-        endPosition,
-        indices
-      });
+      triangulatePolygon(polygons, triangles, { startPosition, endPosition, indices });
     }
-    polygons.triangles = {
-      value: new Uint32Array(triangles),
-      size: 1
-    };
+    polygons.triangles = { value: new Uint32Array(triangles), size: 1 };
   }
   function parseCartoVectorTile(arrayBuffer, options) {
     if (!arrayBuffer)
@@ -10714,9 +10540,9 @@ void main(void) {
   var carto_vector_tile_loader_default = CartoVectorTileLoader;
 
   // src/layers/vector-tile-layer.ts
-  var import_extensions = __toESM(require_extensions());
-  var import_geo_layers6 = __toESM(require_geo_layers());
-  var import_layers3 = __toESM(require_layers());
+  var import_extensions = __toESM(require_extensions(), 1);
+  var import_geo_layers6 = __toESM(require_geo_layers(), 1);
+  var import_layers3 = __toESM(require_layers(), 1);
 
   // ../../node_modules/@loaders.gl/gis/dist/lib/binary-features/binary-to-geojson.js
   function binaryToGeojson(data, options) {
@@ -10922,60 +10748,44 @@ void main(void) {
   var defaultProps8 = {
     ...import_geo_layers6.MVTLayer.defaultProps,
     data: TilejsonPropType,
-    dataComparator: TilejsonPropType.equal
+    dataComparator: TilejsonPropType.equal,
+    tileSize: DEFAULT_TILE_SIZE
   };
   var VectorTileLayer = class extends import_geo_layers6.MVTLayer {
+    constructor(...propObjects) {
+      super(...propObjects);
+    }
     initializeState() {
       super.initializeState();
-      this.setState({
-        binary: true
-      });
+      this.setState({ binary: true });
     }
     updateState(parameters) {
-      const {
-        props
-      } = parameters;
+      const { props } = parameters;
       if (props.data) {
         super.updateState(parameters);
         const formatTiles = new URL(props.data.tiles[0]).searchParams.get("formatTiles");
         const mvt = formatTiles === "mvt";
-        this.setState({
-          mvt
-        });
+        this.setState({ mvt });
       }
     }
     getLoadOptions() {
       const loadOptions = super.getLoadOptions() || {};
       const tileJSON = this.props.data;
       injectAccessToken(loadOptions, tileJSON.accessToken);
-      loadOptions.gis = {
-        format: "binary"
-      };
+      loadOptions.gis = { format: "binary" };
       return loadOptions;
     }
     async getTileData(tile) {
       const tileJSON = this.props.data;
-      const {
-        tiles: tiles2,
-        properties_tiles
-      } = tileJSON;
+      const { tiles: tiles2, properties_tiles } = tileJSON;
       const url = (0, import_geo_layers6._getURLFromTemplate)(tiles2, tile);
       if (!url) {
         return Promise.reject("Invalid URL");
       }
       const loadOptions = this.getLoadOptions();
-      const {
-        fetch: fetch2
-      } = this.props;
-      const {
-        signal
-      } = tile;
-      const geometryFetch = fetch2(url, {
-        propName: "data",
-        layer: this,
-        loadOptions,
-        signal
-      });
+      const { fetch: fetch2 } = this.props;
+      const { signal } = tile;
+      const geometryFetch = fetch2(url, { propName: "data", layer: this, loadOptions, signal });
       if (!properties_tiles) {
         return await geometryFetch;
       }
@@ -11002,12 +10812,7 @@ void main(void) {
         return super.renderSubLayers(props);
       }
       const tileBbox = props.tile.bbox;
-      const {
-        west,
-        south,
-        east,
-        north
-      } = tileBbox;
+      const { west, south, east, north } = tileBbox;
       const subLayerProps = {
         ...props,
         autoHighlight: false,
@@ -11020,9 +10825,7 @@ void main(void) {
     getPickingInfo(params) {
       const info = super.getPickingInfo(params);
       if (this.state.binary && info.index !== -1) {
-        const {
-          data
-        } = params.sourceLayer.props;
+        const { data } = params.sourceLayer.props;
         info.object = binaryToGeojson(data, {
           globalFeatureId: info.index
         });
@@ -11030,8 +10833,8 @@ void main(void) {
       return info;
     }
   };
-  __publicField(VectorTileLayer, "layerName", "VectorTileLayer");
-  __publicField(VectorTileLayer, "defaultProps", defaultProps8);
+  VectorTileLayer.layerName = "VectorTileLayer";
+  VectorTileLayer.defaultProps = defaultProps8;
 
   // src/basemap.ts
   var baseUrl = "https://basemaps.cartocdn.com/gl/{basemap}-gl-style/style.json";
@@ -11098,11 +10901,7 @@ void main(void) {
       const i = left(a, x, lo, hi - 1);
       return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
     }
-    return {
-      left,
-      center,
-      right
-    };
+    return { left, center, right };
   }
   function zero() {
     return 0;
@@ -11211,14 +11010,7 @@ void main(void) {
   var InternMap = class extends Map {
     constructor(entries, key = keyof) {
       super();
-      Object.defineProperties(this, {
-        _intern: {
-          value: /* @__PURE__ */ new Map()
-        },
-        _key: {
-          value: key
-        }
-      });
+      Object.defineProperties(this, { _intern: { value: /* @__PURE__ */ new Map() }, _key: { value: key } });
       if (entries != null)
         for (const [key2, value] of entries)
           this.set(key2, value);
@@ -11236,27 +11028,18 @@ void main(void) {
       return super.delete(intern_delete(this, key));
     }
   };
-  function intern_get({
-    _intern,
-    _key
-  }, value) {
+  function intern_get({ _intern, _key }, value) {
     const key = _key(value);
     return _intern.has(key) ? _intern.get(key) : value;
   }
-  function intern_set({
-    _intern,
-    _key
-  }, value) {
+  function intern_set({ _intern, _key }, value) {
     const key = _key(value);
     if (_intern.has(key))
       return _intern.get(key);
     _intern.set(key, value);
     return value;
   }
-  function intern_delete({
-    _intern,
-    _key
-  }, value) {
+  function intern_delete({ _intern, _key }, value) {
     const key = _key(value);
     if (_intern.has(key)) {
       value = _intern.get(key);
@@ -11659,7 +11442,7 @@ void main(void) {
   }
 
   // ../../node_modules/d3-color/src/color.js
-  function Color() {
+  function Color2() {
   }
   var darker = 0.7;
   var brighter = 1 / darker;
@@ -11823,7 +11606,7 @@ void main(void) {
     yellow: 16776960,
     yellowgreen: 10145074
   };
-  define_default(Color, color, {
+  define_default(Color2, color, {
     copy(channels) {
       return Object.assign(new this.constructor(), this, channels);
     },
@@ -11863,7 +11646,7 @@ void main(void) {
     return new Rgb(r, g, b, a);
   }
   function rgbConvert(o) {
-    if (!(o instanceof Color))
+    if (!(o instanceof Color2))
       o = color(o);
     if (!o)
       return new Rgb();
@@ -11879,7 +11662,7 @@ void main(void) {
     this.b = +b;
     this.opacity = +opacity;
   }
-  define_default(Rgb, rgb, extend(Color, {
+  define_default(Rgb, rgb, extend(Color2, {
     brighter(k) {
       k = k == null ? brighter : Math.pow(brighter, k);
       return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
@@ -11895,7 +11678,7 @@ void main(void) {
       return new Rgb(clampi(this.r), clampi(this.g), clampi(this.b), clampa(this.opacity));
     },
     displayable() {
-      return -0.5 <= this.r && this.r < 255.5 && -0.5 <= this.g && this.g < 255.5 && -0.5 <= this.b && this.b < 255.5 && 0 <= this.opacity && this.opacity <= 1;
+      return -0.5 <= this.r && this.r < 255.5 && (-0.5 <= this.g && this.g < 255.5) && (-0.5 <= this.b && this.b < 255.5) && (0 <= this.opacity && this.opacity <= 1);
     },
     hex: rgb_formatHex,
     formatHex: rgb_formatHex,
@@ -11935,7 +11718,7 @@ void main(void) {
   function hslConvert(o) {
     if (o instanceof Hsl)
       return new Hsl(o.h, o.s, o.l, o.opacity);
-    if (!(o instanceof Color))
+    if (!(o instanceof Color2))
       o = color(o);
     if (!o)
       return new Hsl();
@@ -11966,7 +11749,7 @@ void main(void) {
     this.l = +l;
     this.opacity = +opacity;
   }
-  define_default(Hsl, hsl, extend(Color, {
+  define_default(Hsl, hsl, extend(Color2, {
     brighter(k) {
       k = k == null ? brighter : Math.pow(brighter, k);
       return new Hsl(this.h, this.s, this.l * k, this.opacity);
@@ -11977,13 +11760,18 @@ void main(void) {
     },
     rgb() {
       var h = this.h % 360 + (this.h < 0) * 360, s = isNaN(h) || isNaN(this.s) ? 0 : this.s, l = this.l, m2 = l + (l < 0.5 ? l : 1 - l) * s, m1 = 2 * l - m2;
-      return new Rgb(hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), hsl2rgb(h, m1, m2), hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), this.opacity);
+      return new Rgb(
+        hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2),
+        hsl2rgb(h, m1, m2),
+        hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2),
+        this.opacity
+      );
     },
     clamp() {
       return new Hsl(clamph(this.h), clampt(this.s), clampt(this.l), clampa(this.opacity));
     },
     displayable() {
-      return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && 0 <= this.l && this.l <= 1 && 0 <= this.opacity && this.opacity <= 1;
+      return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && (0 <= this.l && this.l <= 1) && (0 <= this.opacity && this.opacity <= 1);
     },
     formatHsl() {
       const a = clampa(this.opacity);
@@ -12183,10 +11971,7 @@ void main(void) {
           s[++i] = bm;
       } else {
         s[++i] = null;
-        q.push({
-          i,
-          x: number_default(am, bm)
-        });
+        q.push({ i, x: number_default(am, bm) });
       }
       bi = reB.lastIndex;
     }
@@ -12326,7 +12111,10 @@ void main(void) {
     if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e")) < 0)
       return null;
     var i, coefficient = x.slice(0, i);
-    return [coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient, +x.slice(i + 1)];
+    return [
+      coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,
+      +x.slice(i + 1)
+    ];
   }
 
   // ../../node_modules/d3-format/src/exponent.js
@@ -12847,7 +12635,10 @@ void main(void) {
     }
     scale.invertExtent = function(y) {
       var i = range2.indexOf(y);
-      return i < 0 ? [NaN, NaN] : [i > 0 ? thresholds[i - 1] : domain[0], i < thresholds.length ? thresholds[i] : domain[domain.length - 1]];
+      return i < 0 ? [NaN, NaN] : [
+        i > 0 ? thresholds[i - 1] : domain[0],
+        i < thresholds.length ? thresholds[i] : domain[domain.length - 1]
+      ];
     };
     scale.domain = function(_) {
       if (!arguments.length)
@@ -12935,7 +12726,7 @@ void main(void) {
   }
 
   // src/style/palette.ts
-  var cartoColors = __toESM(require_cartocolor2());
+  var cartoColors = __toESM(require_cartocolor2(), 1);
   var DEFAULT_PALETTE = "PurpOr";
   var NULL_COLOR = [204, 204, 204];
   var OTHERS_COLOR = [119, 119, 119];
@@ -12960,11 +12751,21 @@ void main(void) {
   function hexToRgb(hex2) {
     let result = /^#?([a-f\d]{1})([a-f\d]{1})([a-f\d]{1})$/i.exec(hex2);
     if (result) {
-      return [parseInt(result[1] + result[1], 16), parseInt(result[2] + result[2], 16), parseInt(result[3] + result[3], 16), 255];
+      return [
+        parseInt(result[1] + result[1], 16),
+        parseInt(result[2] + result[2], 16),
+        parseInt(result[3] + result[3], 16),
+        255
+      ];
     }
     result = /^#?([a-f\d]{1})([a-f\d]{1})([a-f\d]{1})([a-f\d]{1})$/i.exec(hex2);
     if (result) {
-      return [parseInt(result[1] + result[1], 16), parseInt(result[2] + result[2], 16), parseInt(result[3] + result[3], 16), parseInt(result[4] + result[4], 16)];
+      return [
+        parseInt(result[1] + result[1], 16),
+        parseInt(result[2] + result[2], 16),
+        parseInt(result[3] + result[3], 16),
+        parseInt(result[4] + result[4], 16)
+      ];
     }
     result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex2);
     if (result) {
@@ -12972,7 +12773,12 @@ void main(void) {
     }
     result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex2);
     assert(result, `Hexadecimal color "${hex2}" was not parsed correctly`);
-    return [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16), parseInt(result[4], 16)];
+    return [
+      parseInt(result[1], 16),
+      parseInt(result[2], 16),
+      parseInt(result[3], 16),
+      parseInt(result[4], 16)
+    ];
   }
 
   // src/style/utils.ts
@@ -13080,10 +12886,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   // src/api/common.ts
   var DEFAULT_API_BASE_URL = "https://gcp-us-east1.api.carto.com";
   var DEFAULT_CLIENT = "deck-gl-carto";
-  var V3_MINOR_VERSION = "3.3";
+  var V3_MINOR_VERSION = "3.4";
   var MAX_GET_LENGTH = 8192;
   var DEFAULT_PARAMETERS = {
-    client: DEFAULT_CLIENT,
     v: V3_MINOR_VERSION
   };
   var DEFAULT_HEADERS = {
@@ -13142,62 +12947,44 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     headers: customHeaders,
     errorContext
   }) {
-    const key = JSON.stringify({
-      baseUrl: baseUrl2,
-      parameters,
-      customHeaders
-    });
+    const key = createCacheKey(baseUrl2, parameters || {}, customHeaders || {});
     if (REQUEST_CACHE.has(key)) {
       return REQUEST_CACHE.get(key);
     }
-    let url = baseUrl2;
-    if (parameters) {
-      const allParameters = {
-        ...DEFAULT_PARAMETERS,
-        ...parameters
-      };
-      const encodedParameters = Object.entries(allParameters).map(([key2, value]) => {
-        return encodeParameter(key2, value);
-      });
-      url += `?${encodedParameters.join("&")}`;
-    }
-    const headers = {
-      ...DEFAULT_HEADERS,
-      ...customHeaders
-    };
-    try {
-      let response;
-      if (url.length > MAX_GET_LENGTH) {
-        response = await fetch(baseUrl2, {
-          method: "POST",
-          body: JSON.stringify(parameters),
-          headers
-        });
-      } else {
-        response = await fetch(url, {
-          headers
-        });
-      }
-      let json;
-      try {
-        json = await response.json();
-        if (accessToken) {
-          json.accessToken = accessToken;
-        }
-      } catch {
-        json = {
-          error: ""
-        };
+    const url = parameters ? createURLWithParameters(baseUrl2, parameters) : baseUrl2;
+    const headers = { ...DEFAULT_HEADERS, ...customHeaders };
+    const fetchPromise = url.length > MAX_GET_LENGTH ? fetch(baseUrl2, { method: "POST", body: JSON.stringify(parameters), headers }) : fetch(url, { headers });
+    let response;
+    const jsonPromise = fetchPromise.then((_response) => {
+      response = _response;
+      return response.json();
+    }).then((json) => {
+      if (!response || !response.ok) {
+        throw new Error(json.error);
       }
-      if (!response.ok) {
-        REQUEST_CACHE.delete(key);
-        throw new CartoAPIError(json.error, errorContext, response);
+      if (accessToken) {
+        json.accessToken = accessToken;
       }
-      REQUEST_CACHE.set(key, json);
       return json;
-    } catch (error) {
-      throw new CartoAPIError(error, errorContext);
-    }
+    }).catch((error) => {
+      REQUEST_CACHE.delete(key);
+      throw new CartoAPIError(error, errorContext, response);
+    });
+    REQUEST_CACHE.set(key, jsonPromise);
+    return jsonPromise;
+  }
+  function createCacheKey(baseUrl2, parameters, headers) {
+    const parameterEntries = Object.entries(parameters).sort(([a], [b]) => a > b ? 1 : -1);
+    const headerEntries = Object.entries(headers).sort(([a], [b]) => a > b ? 1 : -1);
+    return JSON.stringify({ baseUrl: baseUrl2, parameters: parameterEntries, headers: headerEntries });
+  }
+  function createURLWithParameters(baseUrl2, parameters) {
+    const encodedParameters = Object.entries({ ...DEFAULT_PARAMETERS, ...parameters }).map(
+      ([key, value]) => {
+        return encodeParameter(key, value);
+      }
+    );
+    return `${baseUrl2}?${encodedParameters.join("&")}`;
   }
 
   // src/sources/base-source.ts
@@ -13208,40 +12995,26 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     headers: {}
   };
   async function baseSource(endpoint, options, urlParameters) {
-    const {
-      accessToken,
-      connectionName,
-      cache,
-      ...optionalOptions
-    } = options;
-    const mergedOptions = {
-      ...SOURCE_DEFAULTS,
-      accessToken,
-      connectionName,
-      endpoint
-    };
+    const { accessToken, connectionName, cache, ...optionalOptions } = options;
+    const mergedOptions = { ...SOURCE_DEFAULTS, accessToken, connectionName, endpoint };
     for (const key in optionalOptions) {
       if (optionalOptions[key]) {
         mergedOptions[key] = optionalOptions[key];
       }
     }
     const baseUrl2 = buildSourceUrl(mergedOptions);
-    const {
-      format: format2
-    } = mergedOptions;
-    const headers = {
-      Authorization: `Bearer ${options.accessToken}`,
-      ...options.headers
-    };
+    const { clientId, format: format2 } = mergedOptions;
+    const headers = { Authorization: `Bearer ${options.accessToken}`, ...options.headers };
+    const parameters = { client: clientId, ...urlParameters };
     const errorContext = {
       requestType: "Map instantiation",
       connection: options.connectionName,
       type: endpoint,
-      source: JSON.stringify(urlParameters, void 0, 2)
+      source: JSON.stringify(parameters, void 0, 2)
     };
     const mapInstantiation = await requestWithParameters({
       baseUrl: baseUrl2,
-      parameters: urlParameters,
+      parameters,
       headers,
       errorContext
     });
@@ -13268,6 +13041,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   // src/sources/boundary-query-source.ts
   var boundaryQuerySource = async function(options) {
     const {
+      columns,
+      filters,
       tilesetTableName,
       matchingColumn = "id",
       propertiesSqlQuery,
@@ -13278,6 +13053,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       matchingColumn,
       propertiesSqlQuery
     };
+    if (columns) {
+      urlParameters.columns = columns.join(",");
+    }
+    if (filters) {
+      urlParameters.filters = JSON.stringify(filters);
+    }
     if (queryParameters) {
       urlParameters.queryParameters = JSON.stringify(queryParameters);
     }
@@ -13286,12 +13067,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // src/sources/boundary-table-source.ts
   var boundaryTableSource = async function(options) {
-    const {
-      tilesetTableName,
-      columns,
-      matchingColumn = "id",
-      propertiesTableName
-    } = options;
+    const { filters, tilesetTableName, columns, matchingColumn = "id", propertiesTableName } = options;
     const urlParameters = {
       tilesetTableName,
       matchingColumn,
@@ -13300,6 +13076,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (columns) {
       urlParameters.columns = columns.join(",");
     }
+    if (filters) {
+      urlParameters.filters = JSON.stringify(filters);
+    }
     return baseSource("boundary", options, urlParameters);
   };
 
@@ -13307,7 +13086,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var h3QuerySource = async function(options) {
     const {
       aggregationExp,
-      aggregationResLevel = 4,
+      aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
       sqlQuery,
       spatialDataColumn = "h3",
       queryParameters
@@ -13331,8 +13110,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var h3TableSource = async function(options) {
     const {
       aggregationExp,
-      aggregationResLevel = 4,
-      columns,
+      aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
       spatialDataColumn = "h3",
       tableName
     } = options;
@@ -13345,31 +13123,20 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (aggregationResLevel) {
       urlParameters.aggregationResLevel = String(aggregationResLevel);
     }
-    if (columns) {
-      urlParameters.columns = columns.join(",");
-    }
     return baseSource("table", options, urlParameters);
   };
 
   // src/sources/h3-tileset-source.ts
   var h3TilesetSource = async function(options) {
-    const {
-      tableName
-    } = options;
-    const urlParameters = {
-      name: tableName
-    };
+    const { tableName } = options;
+    const urlParameters = { name: tableName };
     return baseSource("tileset", options, urlParameters);
   };
 
   // src/sources/raster-source.ts
   var rasterSource = async function(options) {
-    const {
-      tableName
-    } = options;
-    const urlParameters = {
-      name: tableName
-    };
+    const { tableName } = options;
+    const urlParameters = { name: tableName };
     return baseSource("raster", options, urlParameters);
   };
 
@@ -13377,7 +13144,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var quadbinQuerySource = async function(options) {
     const {
       aggregationExp,
-      aggregationResLevel = 6,
+      aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
       sqlQuery,
       spatialDataColumn = "quadbin",
       queryParameters
@@ -13401,8 +13168,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var quadbinTableSource = async function(options) {
     const {
       aggregationExp,
-      aggregationResLevel = 6,
-      columns,
+      aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
       spatialDataColumn = "quadbin",
       tableName
     } = options;
@@ -13415,35 +13181,38 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (aggregationResLevel) {
       urlParameters.aggregationResLevel = String(aggregationResLevel);
     }
-    if (columns) {
-      urlParameters.columns = columns.join(",");
-    }
     return baseSource("table", options, urlParameters);
   };
 
   // src/sources/quadbin-tileset-source.ts
   var quadbinTilesetSource = async function(options) {
-    const {
-      tableName
-    } = options;
-    const urlParameters = {
-      name: tableName
-    };
+    const { tableName } = options;
+    const urlParameters = { name: tableName };
     return baseSource("tileset", options, urlParameters);
   };
 
   // src/sources/vector-query-source.ts
   var vectorQuerySource = async function(options) {
     const {
+      columns,
+      filters,
       spatialDataColumn = "geom",
       sqlQuery,
+      tileResolution = DEFAULT_TILE_RESOLUTION,
       queryParameters
     } = options;
     const urlParameters = {
       spatialDataColumn,
       spatialDataType: "geo",
+      tileResolution: tileResolution.toString(),
       q: sqlQuery
     };
+    if (columns) {
+      urlParameters.columns = columns.join(",");
+    }
+    if (filters) {
+      urlParameters.filters = JSON.stringify(filters);
+    }
     if (queryParameters) {
       urlParameters.queryParameters = JSON.stringify(queryParameters);
     }
@@ -13454,39 +13223,692 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   var vectorTableSource = async function(options) {
     const {
       columns,
+      filters,
       spatialDataColumn = "geom",
-      tableName
+      tableName,
+      tileResolution = DEFAULT_TILE_RESOLUTION
     } = options;
     const urlParameters = {
       name: tableName,
       spatialDataColumn,
-      spatialDataType: "geo"
+      spatialDataType: "geo",
+      tileResolution: tileResolution.toString()
     };
     if (columns) {
       urlParameters.columns = columns.join(",");
     }
+    if (filters) {
+      urlParameters.filters = JSON.stringify(filters);
+    }
     return baseSource("table", options, urlParameters);
   };
 
   // src/sources/vector-tileset-source.ts
   var vectorTilesetSource = async function(options) {
-    const {
-      tableName
-    } = options;
-    const urlParameters = {
-      name: tableName
-    };
+    const { tableName } = options;
+    const urlParameters = { name: tableName };
     return baseSource("tileset", options, urlParameters);
   };
 
+  // ../../node_modules/@luma.gl/constants/dist/webgl-constants.js
+  var GLEnum;
+  (function(GLEnum2) {
+    GLEnum2[GLEnum2["DEPTH_BUFFER_BIT"] = 256] = "DEPTH_BUFFER_BIT";
+    GLEnum2[GLEnum2["STENCIL_BUFFER_BIT"] = 1024] = "STENCIL_BUFFER_BIT";
+    GLEnum2[GLEnum2["COLOR_BUFFER_BIT"] = 16384] = "COLOR_BUFFER_BIT";
+    GLEnum2[GLEnum2["POINTS"] = 0] = "POINTS";
+    GLEnum2[GLEnum2["LINES"] = 1] = "LINES";
+    GLEnum2[GLEnum2["LINE_LOOP"] = 2] = "LINE_LOOP";
+    GLEnum2[GLEnum2["LINE_STRIP"] = 3] = "LINE_STRIP";
+    GLEnum2[GLEnum2["TRIANGLES"] = 4] = "TRIANGLES";
+    GLEnum2[GLEnum2["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
+    GLEnum2[GLEnum2["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
+    GLEnum2[GLEnum2["ZERO"] = 0] = "ZERO";
+    GLEnum2[GLEnum2["ONE"] = 1] = "ONE";
+    GLEnum2[GLEnum2["SRC_COLOR"] = 768] = "SRC_COLOR";
+    GLEnum2[GLEnum2["ONE_MINUS_SRC_COLOR"] = 769] = "ONE_MINUS_SRC_COLOR";
+    GLEnum2[GLEnum2["SRC_ALPHA"] = 770] = "SRC_ALPHA";
+    GLEnum2[GLEnum2["ONE_MINUS_SRC_ALPHA"] = 771] = "ONE_MINUS_SRC_ALPHA";
+    GLEnum2[GLEnum2["DST_ALPHA"] = 772] = "DST_ALPHA";
+    GLEnum2[GLEnum2["ONE_MINUS_DST_ALPHA"] = 773] = "ONE_MINUS_DST_ALPHA";
+    GLEnum2[GLEnum2["DST_COLOR"] = 774] = "DST_COLOR";
+    GLEnum2[GLEnum2["ONE_MINUS_DST_COLOR"] = 775] = "ONE_MINUS_DST_COLOR";
+    GLEnum2[GLEnum2["SRC_ALPHA_SATURATE"] = 776] = "SRC_ALPHA_SATURATE";
+    GLEnum2[GLEnum2["CONSTANT_COLOR"] = 32769] = "CONSTANT_COLOR";
+    GLEnum2[GLEnum2["ONE_MINUS_CONSTANT_COLOR"] = 32770] = "ONE_MINUS_CONSTANT_COLOR";
+    GLEnum2[GLEnum2["CONSTANT_ALPHA"] = 32771] = "CONSTANT_ALPHA";
+    GLEnum2[GLEnum2["ONE_MINUS_CONSTANT_ALPHA"] = 32772] = "ONE_MINUS_CONSTANT_ALPHA";
+    GLEnum2[GLEnum2["FUNC_ADD"] = 32774] = "FUNC_ADD";
+    GLEnum2[GLEnum2["FUNC_SUBTRACT"] = 32778] = "FUNC_SUBTRACT";
+    GLEnum2[GLEnum2["FUNC_REVERSE_SUBTRACT"] = 32779] = "FUNC_REVERSE_SUBTRACT";
+    GLEnum2[GLEnum2["BLEND_EQUATION"] = 32777] = "BLEND_EQUATION";
+    GLEnum2[GLEnum2["BLEND_EQUATION_RGB"] = 32777] = "BLEND_EQUATION_RGB";
+    GLEnum2[GLEnum2["BLEND_EQUATION_ALPHA"] = 34877] = "BLEND_EQUATION_ALPHA";
+    GLEnum2[GLEnum2["BLEND_DST_RGB"] = 32968] = "BLEND_DST_RGB";
+    GLEnum2[GLEnum2["BLEND_SRC_RGB"] = 32969] = "BLEND_SRC_RGB";
+    GLEnum2[GLEnum2["BLEND_DST_ALPHA"] = 32970] = "BLEND_DST_ALPHA";
+    GLEnum2[GLEnum2["BLEND_SRC_ALPHA"] = 32971] = "BLEND_SRC_ALPHA";
+    GLEnum2[GLEnum2["BLEND_COLOR"] = 32773] = "BLEND_COLOR";
+    GLEnum2[GLEnum2["ARRAY_BUFFER_BINDING"] = 34964] = "ARRAY_BUFFER_BINDING";
+    GLEnum2[GLEnum2["ELEMENT_ARRAY_BUFFER_BINDING"] = 34965] = "ELEMENT_ARRAY_BUFFER_BINDING";
+    GLEnum2[GLEnum2["LINE_WIDTH"] = 2849] = "LINE_WIDTH";
+    GLEnum2[GLEnum2["ALIASED_POINT_SIZE_RANGE"] = 33901] = "ALIASED_POINT_SIZE_RANGE";
+    GLEnum2[GLEnum2["ALIASED_LINE_WIDTH_RANGE"] = 33902] = "ALIASED_LINE_WIDTH_RANGE";
+    GLEnum2[GLEnum2["CULL_FACE_MODE"] = 2885] = "CULL_FACE_MODE";
+    GLEnum2[GLEnum2["FRONT_FACE"] = 2886] = "FRONT_FACE";
+    GLEnum2[GLEnum2["DEPTH_RANGE"] = 2928] = "DEPTH_RANGE";
+    GLEnum2[GLEnum2["DEPTH_WRITEMASK"] = 2930] = "DEPTH_WRITEMASK";
+    GLEnum2[GLEnum2["DEPTH_CLEAR_VALUE"] = 2931] = "DEPTH_CLEAR_VALUE";
+    GLEnum2[GLEnum2["DEPTH_FUNC"] = 2932] = "DEPTH_FUNC";
+    GLEnum2[GLEnum2["STENCIL_CLEAR_VALUE"] = 2961] = "STENCIL_CLEAR_VALUE";
+    GLEnum2[GLEnum2["STENCIL_FUNC"] = 2962] = "STENCIL_FUNC";
+    GLEnum2[GLEnum2["STENCIL_FAIL"] = 2964] = "STENCIL_FAIL";
+    GLEnum2[GLEnum2["STENCIL_PASS_DEPTH_FAIL"] = 2965] = "STENCIL_PASS_DEPTH_FAIL";
+    GLEnum2[GLEnum2["STENCIL_PASS_DEPTH_PASS"] = 2966] = "STENCIL_PASS_DEPTH_PASS";
+    GLEnum2[GLEnum2["STENCIL_REF"] = 2967] = "STENCIL_REF";
+    GLEnum2[GLEnum2["STENCIL_VALUE_MASK"] = 2963] = "STENCIL_VALUE_MASK";
+    GLEnum2[GLEnum2["STENCIL_WRITEMASK"] = 2968] = "STENCIL_WRITEMASK";
+    GLEnum2[GLEnum2["STENCIL_BACK_FUNC"] = 34816] = "STENCIL_BACK_FUNC";
+    GLEnum2[GLEnum2["STENCIL_BACK_FAIL"] = 34817] = "STENCIL_BACK_FAIL";
+    GLEnum2[GLEnum2["STENCIL_BACK_PASS_DEPTH_FAIL"] = 34818] = "STENCIL_BACK_PASS_DEPTH_FAIL";
+    GLEnum2[GLEnum2["STENCIL_BACK_PASS_DEPTH_PASS"] = 34819] = "STENCIL_BACK_PASS_DEPTH_PASS";
+    GLEnum2[GLEnum2["STENCIL_BACK_REF"] = 36003] = "STENCIL_BACK_REF";
+    GLEnum2[GLEnum2["STENCIL_BACK_VALUE_MASK"] = 36004] = "STENCIL_BACK_VALUE_MASK";
+    GLEnum2[GLEnum2["STENCIL_BACK_WRITEMASK"] = 36005] = "STENCIL_BACK_WRITEMASK";
+    GLEnum2[GLEnum2["VIEWPORT"] = 2978] = "VIEWPORT";
+    GLEnum2[GLEnum2["SCISSOR_BOX"] = 3088] = "SCISSOR_BOX";
+    GLEnum2[GLEnum2["COLOR_CLEAR_VALUE"] = 3106] = "COLOR_CLEAR_VALUE";
+    GLEnum2[GLEnum2["COLOR_WRITEMASK"] = 3107] = "COLOR_WRITEMASK";
+    GLEnum2[GLEnum2["UNPACK_ALIGNMENT"] = 3317] = "UNPACK_ALIGNMENT";
+    GLEnum2[GLEnum2["PACK_ALIGNMENT"] = 3333] = "PACK_ALIGNMENT";
+    GLEnum2[GLEnum2["MAX_TEXTURE_SIZE"] = 3379] = "MAX_TEXTURE_SIZE";
+    GLEnum2[GLEnum2["MAX_VIEWPORT_DIMS"] = 3386] = "MAX_VIEWPORT_DIMS";
+    GLEnum2[GLEnum2["SUBPIXEL_BITS"] = 3408] = "SUBPIXEL_BITS";
+    GLEnum2[GLEnum2["RED_BITS"] = 3410] = "RED_BITS";
+    GLEnum2[GLEnum2["GREEN_BITS"] = 3411] = "GREEN_BITS";
+    GLEnum2[GLEnum2["BLUE_BITS"] = 3412] = "BLUE_BITS";
+    GLEnum2[GLEnum2["ALPHA_BITS"] = 3413] = "ALPHA_BITS";
+    GLEnum2[GLEnum2["DEPTH_BITS"] = 3414] = "DEPTH_BITS";
+    GLEnum2[GLEnum2["STENCIL_BITS"] = 3415] = "STENCIL_BITS";
+    GLEnum2[GLEnum2["POLYGON_OFFSET_UNITS"] = 10752] = "POLYGON_OFFSET_UNITS";
+    GLEnum2[GLEnum2["POLYGON_OFFSET_FACTOR"] = 32824] = "POLYGON_OFFSET_FACTOR";
+    GLEnum2[GLEnum2["TEXTURE_BINDING_2D"] = 32873] = "TEXTURE_BINDING_2D";
+    GLEnum2[GLEnum2["SAMPLE_BUFFERS"] = 32936] = "SAMPLE_BUFFERS";
+    GLEnum2[GLEnum2["SAMPLES"] = 32937] = "SAMPLES";
+    GLEnum2[GLEnum2["SAMPLE_COVERAGE_VALUE"] = 32938] = "SAMPLE_COVERAGE_VALUE";
+    GLEnum2[GLEnum2["SAMPLE_COVERAGE_INVERT"] = 32939] = "SAMPLE_COVERAGE_INVERT";
+    GLEnum2[GLEnum2["COMPRESSED_TEXTURE_FORMATS"] = 34467] = "COMPRESSED_TEXTURE_FORMATS";
+    GLEnum2[GLEnum2["VENDOR"] = 7936] = "VENDOR";
+    GLEnum2[GLEnum2["RENDERER"] = 7937] = "RENDERER";
+    GLEnum2[GLEnum2["VERSION"] = 7938] = "VERSION";
+    GLEnum2[GLEnum2["IMPLEMENTATION_COLOR_READ_TYPE"] = 35738] = "IMPLEMENTATION_COLOR_READ_TYPE";
+    GLEnum2[GLEnum2["IMPLEMENTATION_COLOR_READ_FORMAT"] = 35739] = "IMPLEMENTATION_COLOR_READ_FORMAT";
+    GLEnum2[GLEnum2["BROWSER_DEFAULT_WEBGL"] = 37444] = "BROWSER_DEFAULT_WEBGL";
+    GLEnum2[GLEnum2["STATIC_DRAW"] = 35044] = "STATIC_DRAW";
+    GLEnum2[GLEnum2["STREAM_DRAW"] = 35040] = "STREAM_DRAW";
+    GLEnum2[GLEnum2["DYNAMIC_DRAW"] = 35048] = "DYNAMIC_DRAW";
+    GLEnum2[GLEnum2["ARRAY_BUFFER"] = 34962] = "ARRAY_BUFFER";
+    GLEnum2[GLEnum2["ELEMENT_ARRAY_BUFFER"] = 34963] = "ELEMENT_ARRAY_BUFFER";
+    GLEnum2[GLEnum2["BUFFER_SIZE"] = 34660] = "BUFFER_SIZE";
+    GLEnum2[GLEnum2["BUFFER_USAGE"] = 34661] = "BUFFER_USAGE";
+    GLEnum2[GLEnum2["CURRENT_VERTEX_ATTRIB"] = 34342] = "CURRENT_VERTEX_ATTRIB";
+    GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_ENABLED"] = 34338] = "VERTEX_ATTRIB_ARRAY_ENABLED";
+    GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_SIZE"] = 34339] = "VERTEX_ATTRIB_ARRAY_SIZE";
+    GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_STRIDE"] = 34340] = "VERTEX_ATTRIB_ARRAY_STRIDE";
+    GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_TYPE"] = 34341] = "VERTEX_ATTRIB_ARRAY_TYPE";
+    GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_NORMALIZED"] = 34922] = "VERTEX_ATTRIB_ARRAY_NORMALIZED";
+    GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_POINTER"] = 34373] = "VERTEX_ATTRIB_ARRAY_POINTER";
+    GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"] = 34975] = "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING";
+    GLEnum2[GLEnum2["CULL_FACE"] = 2884] = "CULL_FACE";
+    GLEnum2[GLEnum2["FRONT"] = 1028] = "FRONT";
+    GLEnum2[GLEnum2["BACK"] = 1029] = "BACK";
+    GLEnum2[GLEnum2["FRONT_AND_BACK"] = 1032] = "FRONT_AND_BACK";
+    GLEnum2[GLEnum2["BLEND"] = 3042] = "BLEND";
+    GLEnum2[GLEnum2["DEPTH_TEST"] = 2929] = "DEPTH_TEST";
+    GLEnum2[GLEnum2["DITHER"] = 3024] = "DITHER";
+    GLEnum2[GLEnum2["POLYGON_OFFSET_FILL"] = 32823] = "POLYGON_OFFSET_FILL";
+    GLEnum2[GLEnum2["SAMPLE_ALPHA_TO_COVERAGE"] = 32926] = "SAMPLE_ALPHA_TO_COVERAGE";
+    GLEnum2[GLEnum2["SAMPLE_COVERAGE"] = 32928] = "SAMPLE_COVERAGE";
+    GLEnum2[GLEnum2["SCISSOR_TEST"] = 3089] = "SCISSOR_TEST";
+    GLEnum2[GLEnum2["STENCIL_TEST"] = 2960] = "STENCIL_TEST";
+    GLEnum2[GLEnum2["NO_ERROR"] = 0] = "NO_ERROR";
+    GLEnum2[GLEnum2["INVALID_ENUM"] = 1280] = "INVALID_ENUM";
+    GLEnum2[GLEnum2["INVALID_VALUE"] = 1281] = "INVALID_VALUE";
+    GLEnum2[GLEnum2["INVALID_OPERATION"] = 1282] = "INVALID_OPERATION";
+    GLEnum2[GLEnum2["OUT_OF_MEMORY"] = 1285] = "OUT_OF_MEMORY";
+    GLEnum2[GLEnum2["CONTEXT_LOST_WEBGL"] = 37442] = "CONTEXT_LOST_WEBGL";
+    GLEnum2[GLEnum2["CW"] = 2304] = "CW";
+    GLEnum2[GLEnum2["CCW"] = 2305] = "CCW";
+    GLEnum2[GLEnum2["DONT_CARE"] = 4352] = "DONT_CARE";
+    GLEnum2[GLEnum2["FASTEST"] = 4353] = "FASTEST";
+    GLEnum2[GLEnum2["NICEST"] = 4354] = "NICEST";
+    GLEnum2[GLEnum2["GENERATE_MIPMAP_HINT"] = 33170] = "GENERATE_MIPMAP_HINT";
+    GLEnum2[GLEnum2["BYTE"] = 5120] = "BYTE";
+    GLEnum2[GLEnum2["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
+    GLEnum2[GLEnum2["SHORT"] = 5122] = "SHORT";
+    GLEnum2[GLEnum2["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
+    GLEnum2[GLEnum2["INT"] = 5124] = "INT";
+    GLEnum2[GLEnum2["UNSIGNED_INT"] = 5125] = "UNSIGNED_INT";
+    GLEnum2[GLEnum2["FLOAT"] = 5126] = "FLOAT";
+    GLEnum2[GLEnum2["DOUBLE"] = 5130] = "DOUBLE";
+    GLEnum2[GLEnum2["DEPTH_COMPONENT"] = 6402] = "DEPTH_COMPONENT";
+    GLEnum2[GLEnum2["ALPHA"] = 6406] = "ALPHA";
+    GLEnum2[GLEnum2["RGB"] = 6407] = "RGB";
+    GLEnum2[GLEnum2["RGBA"] = 6408] = "RGBA";
+    GLEnum2[GLEnum2["LUMINANCE"] = 6409] = "LUMINANCE";
+    GLEnum2[GLEnum2["LUMINANCE_ALPHA"] = 6410] = "LUMINANCE_ALPHA";
+    GLEnum2[GLEnum2["UNSIGNED_SHORT_4_4_4_4"] = 32819] = "UNSIGNED_SHORT_4_4_4_4";
+    GLEnum2[GLEnum2["UNSIGNED_SHORT_5_5_5_1"] = 32820] = "UNSIGNED_SHORT_5_5_5_1";
+    GLEnum2[GLEnum2["UNSIGNED_SHORT_5_6_5"] = 33635] = "UNSIGNED_SHORT_5_6_5";
+    GLEnum2[GLEnum2["FRAGMENT_SHADER"] = 35632] = "FRAGMENT_SHADER";
+    GLEnum2[GLEnum2["VERTEX_SHADER"] = 35633] = "VERTEX_SHADER";
+    GLEnum2[GLEnum2["COMPILE_STATUS"] = 35713] = "COMPILE_STATUS";
+    GLEnum2[GLEnum2["DELETE_STATUS"] = 35712] = "DELETE_STATUS";
+    GLEnum2[GLEnum2["LINK_STATUS"] = 35714] = "LINK_STATUS";
+    GLEnum2[GLEnum2["VALIDATE_STATUS"] = 35715] = "VALIDATE_STATUS";
+    GLEnum2[GLEnum2["ATTACHED_SHADERS"] = 35717] = "ATTACHED_SHADERS";
+    GLEnum2[GLEnum2["ACTIVE_ATTRIBUTES"] = 35721] = "ACTIVE_ATTRIBUTES";
+    GLEnum2[GLEnum2["ACTIVE_UNIFORMS"] = 35718] = "ACTIVE_UNIFORMS";
+    GLEnum2[GLEnum2["MAX_VERTEX_ATTRIBS"] = 34921] = "MAX_VERTEX_ATTRIBS";
+    GLEnum2[GLEnum2["MAX_VERTEX_UNIFORM_VECTORS"] = 36347] = "MAX_VERTEX_UNIFORM_VECTORS";
+    GLEnum2[GLEnum2["MAX_VARYING_VECTORS"] = 36348] = "MAX_VARYING_VECTORS";
+    GLEnum2[GLEnum2["MAX_COMBINED_TEXTURE_IMAGE_UNITS"] = 35661] = "MAX_COMBINED_TEXTURE_IMAGE_UNITS";
+    GLEnum2[GLEnum2["MAX_VERTEX_TEXTURE_IMAGE_UNITS"] = 35660] = "MAX_VERTEX_TEXTURE_IMAGE_UNITS";
+    GLEnum2[GLEnum2["MAX_TEXTURE_IMAGE_UNITS"] = 34930] = "MAX_TEXTURE_IMAGE_UNITS";
+    GLEnum2[GLEnum2["MAX_FRAGMENT_UNIFORM_VECTORS"] = 36349] = "MAX_FRAGMENT_UNIFORM_VECTORS";
+    GLEnum2[GLEnum2["SHADER_TYPE"] = 35663] = "SHADER_TYPE";
+    GLEnum2[GLEnum2["SHADING_LANGUAGE_VERSION"] = 35724] = "SHADING_LANGUAGE_VERSION";
+    GLEnum2[GLEnum2["CURRENT_PROGRAM"] = 35725] = "CURRENT_PROGRAM";
+    GLEnum2[GLEnum2["NEVER"] = 512] = "NEVER";
+    GLEnum2[GLEnum2["LESS"] = 513] = "LESS";
+    GLEnum2[GLEnum2["EQUAL"] = 514] = "EQUAL";
+    GLEnum2[GLEnum2["LEQUAL"] = 515] = "LEQUAL";
+    GLEnum2[GLEnum2["GREATER"] = 516] = "GREATER";
+    GLEnum2[GLEnum2["NOTEQUAL"] = 517] = "NOTEQUAL";
+    GLEnum2[GLEnum2["GEQUAL"] = 518] = "GEQUAL";
+    GLEnum2[GLEnum2["ALWAYS"] = 519] = "ALWAYS";
+    GLEnum2[GLEnum2["KEEP"] = 7680] = "KEEP";
+    GLEnum2[GLEnum2["REPLACE"] = 7681] = "REPLACE";
+    GLEnum2[GLEnum2["INCR"] = 7682] = "INCR";
+    GLEnum2[GLEnum2["DECR"] = 7683] = "DECR";
+    GLEnum2[GLEnum2["INVERT"] = 5386] = "INVERT";
+    GLEnum2[GLEnum2["INCR_WRAP"] = 34055] = "INCR_WRAP";
+    GLEnum2[GLEnum2["DECR_WRAP"] = 34056] = "DECR_WRAP";
+    GLEnum2[GLEnum2["NEAREST"] = 9728] = "NEAREST";
+    GLEnum2[GLEnum2["LINEAR"] = 9729] = "LINEAR";
+    GLEnum2[GLEnum2["NEAREST_MIPMAP_NEAREST"] = 9984] = "NEAREST_MIPMAP_NEAREST";
+    GLEnum2[GLEnum2["LINEAR_MIPMAP_NEAREST"] = 9985] = "LINEAR_MIPMAP_NEAREST";
+    GLEnum2[GLEnum2["NEAREST_MIPMAP_LINEAR"] = 9986] = "NEAREST_MIPMAP_LINEAR";
+    GLEnum2[GLEnum2["LINEAR_MIPMAP_LINEAR"] = 9987] = "LINEAR_MIPMAP_LINEAR";
+    GLEnum2[GLEnum2["TEXTURE_MAG_FILTER"] = 10240] = "TEXTURE_MAG_FILTER";
+    GLEnum2[GLEnum2["TEXTURE_MIN_FILTER"] = 10241] = "TEXTURE_MIN_FILTER";
+    GLEnum2[GLEnum2["TEXTURE_WRAP_S"] = 10242] = "TEXTURE_WRAP_S";
+    GLEnum2[GLEnum2["TEXTURE_WRAP_T"] = 10243] = "TEXTURE_WRAP_T";
+    GLEnum2[GLEnum2["TEXTURE_2D"] = 3553] = "TEXTURE_2D";
+    GLEnum2[GLEnum2["TEXTURE"] = 5890] = "TEXTURE";
+    GLEnum2[GLEnum2["TEXTURE_CUBE_MAP"] = 34067] = "TEXTURE_CUBE_MAP";
+    GLEnum2[GLEnum2["TEXTURE_BINDING_CUBE_MAP"] = 34068] = "TEXTURE_BINDING_CUBE_MAP";
+    GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_POSITIVE_X"] = 34069] = "TEXTURE_CUBE_MAP_POSITIVE_X";
+    GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_NEGATIVE_X"] = 34070] = "TEXTURE_CUBE_MAP_NEGATIVE_X";
+    GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_POSITIVE_Y"] = 34071] = "TEXTURE_CUBE_MAP_POSITIVE_Y";
+    GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_NEGATIVE_Y"] = 34072] = "TEXTURE_CUBE_MAP_NEGATIVE_Y";
+    GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_POSITIVE_Z"] = 34073] = "TEXTURE_CUBE_MAP_POSITIVE_Z";
+    GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_NEGATIVE_Z"] = 34074] = "TEXTURE_CUBE_MAP_NEGATIVE_Z";
+    GLEnum2[GLEnum2["MAX_CUBE_MAP_TEXTURE_SIZE"] = 34076] = "MAX_CUBE_MAP_TEXTURE_SIZE";
+    GLEnum2[GLEnum2["TEXTURE0"] = 33984] = "TEXTURE0";
+    GLEnum2[GLEnum2["ACTIVE_TEXTURE"] = 34016] = "ACTIVE_TEXTURE";
+    GLEnum2[GLEnum2["REPEAT"] = 10497] = "REPEAT";
+    GLEnum2[GLEnum2["CLAMP_TO_EDGE"] = 33071] = "CLAMP_TO_EDGE";
+    GLEnum2[GLEnum2["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT";
+    GLEnum2[GLEnum2["TEXTURE_WIDTH"] = 4096] = "TEXTURE_WIDTH";
+    GLEnum2[GLEnum2["TEXTURE_HEIGHT"] = 4097] = "TEXTURE_HEIGHT";
+    GLEnum2[GLEnum2["FLOAT_VEC2"] = 35664] = "FLOAT_VEC2";
+    GLEnum2[GLEnum2["FLOAT_VEC3"] = 35665] = "FLOAT_VEC3";
+    GLEnum2[GLEnum2["FLOAT_VEC4"] = 35666] = "FLOAT_VEC4";
+    GLEnum2[GLEnum2["INT_VEC2"] = 35667] = "INT_VEC2";
+    GLEnum2[GLEnum2["INT_VEC3"] = 35668] = "INT_VEC3";
+    GLEnum2[GLEnum2["INT_VEC4"] = 35669] = "INT_VEC4";
+    GLEnum2[GLEnum2["BOOL"] = 35670] = "BOOL";
+    GLEnum2[GLEnum2["BOOL_VEC2"] = 35671] = "BOOL_VEC2";
+    GLEnum2[GLEnum2["BOOL_VEC3"] = 35672] = "BOOL_VEC3";
+    GLEnum2[GLEnum2["BOOL_VEC4"] = 35673] = "BOOL_VEC4";
+    GLEnum2[GLEnum2["FLOAT_MAT2"] = 35674] = "FLOAT_MAT2";
+    GLEnum2[GLEnum2["FLOAT_MAT3"] = 35675] = "FLOAT_MAT3";
+    GLEnum2[GLEnum2["FLOAT_MAT4"] = 35676] = "FLOAT_MAT4";
+    GLEnum2[GLEnum2["SAMPLER_2D"] = 35678] = "SAMPLER_2D";
+    GLEnum2[GLEnum2["SAMPLER_CUBE"] = 35680] = "SAMPLER_CUBE";
+    GLEnum2[GLEnum2["LOW_FLOAT"] = 36336] = "LOW_FLOAT";
+    GLEnum2[GLEnum2["MEDIUM_FLOAT"] = 36337] = "MEDIUM_FLOAT";
+    GLEnum2[GLEnum2["HIGH_FLOAT"] = 36338] = "HIGH_FLOAT";
+    GLEnum2[GLEnum2["LOW_INT"] = 36339] = "LOW_INT";
+    GLEnum2[GLEnum2["MEDIUM_INT"] = 36340] = "MEDIUM_INT";
+    GLEnum2[GLEnum2["HIGH_INT"] = 36341] = "HIGH_INT";
+    GLEnum2[GLEnum2["FRAMEBUFFER"] = 36160] = "FRAMEBUFFER";
+    GLEnum2[GLEnum2["RENDERBUFFER"] = 36161] = "RENDERBUFFER";
+    GLEnum2[GLEnum2["RGBA4"] = 32854] = "RGBA4";
+    GLEnum2[GLEnum2["RGB5_A1"] = 32855] = "RGB5_A1";
+    GLEnum2[GLEnum2["RGB565"] = 36194] = "RGB565";
+    GLEnum2[GLEnum2["DEPTH_COMPONENT16"] = 33189] = "DEPTH_COMPONENT16";
+    GLEnum2[GLEnum2["STENCIL_INDEX"] = 6401] = "STENCIL_INDEX";
+    GLEnum2[GLEnum2["STENCIL_INDEX8"] = 36168] = "STENCIL_INDEX8";
+    GLEnum2[GLEnum2["DEPTH_STENCIL"] = 34041] = "DEPTH_STENCIL";
+    GLEnum2[GLEnum2["RENDERBUFFER_WIDTH"] = 36162] = "RENDERBUFFER_WIDTH";
+    GLEnum2[GLEnum2["RENDERBUFFER_HEIGHT"] = 36163] = "RENDERBUFFER_HEIGHT";
+    GLEnum2[GLEnum2["RENDERBUFFER_INTERNAL_FORMAT"] = 36164] = "RENDERBUFFER_INTERNAL_FORMAT";
+    GLEnum2[GLEnum2["RENDERBUFFER_RED_SIZE"] = 36176] = "RENDERBUFFER_RED_SIZE";
+    GLEnum2[GLEnum2["RENDERBUFFER_GREEN_SIZE"] = 36177] = "RENDERBUFFER_GREEN_SIZE";
+    GLEnum2[GLEnum2["RENDERBUFFER_BLUE_SIZE"] = 36178] = "RENDERBUFFER_BLUE_SIZE";
+    GLEnum2[GLEnum2["RENDERBUFFER_ALPHA_SIZE"] = 36179] = "RENDERBUFFER_ALPHA_SIZE";
+    GLEnum2[GLEnum2["RENDERBUFFER_DEPTH_SIZE"] = 36180] = "RENDERBUFFER_DEPTH_SIZE";
+    GLEnum2[GLEnum2["RENDERBUFFER_STENCIL_SIZE"] = 36181] = "RENDERBUFFER_STENCIL_SIZE";
+    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"] = 36048] = "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE";
+    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"] = 36049] = "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME";
+    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"] = 36050] = "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL";
+    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"] = 36051] = "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT0"] = 36064] = "COLOR_ATTACHMENT0";
+    GLEnum2[GLEnum2["DEPTH_ATTACHMENT"] = 36096] = "DEPTH_ATTACHMENT";
+    GLEnum2[GLEnum2["STENCIL_ATTACHMENT"] = 36128] = "STENCIL_ATTACHMENT";
+    GLEnum2[GLEnum2["DEPTH_STENCIL_ATTACHMENT"] = 33306] = "DEPTH_STENCIL_ATTACHMENT";
+    GLEnum2[GLEnum2["NONE"] = 0] = "NONE";
+    GLEnum2[GLEnum2["FRAMEBUFFER_COMPLETE"] = 36053] = "FRAMEBUFFER_COMPLETE";
+    GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_ATTACHMENT"] = 36054] = "FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
+    GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"] = 36055] = "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
+    GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_DIMENSIONS"] = 36057] = "FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
+    GLEnum2[GLEnum2["FRAMEBUFFER_UNSUPPORTED"] = 36061] = "FRAMEBUFFER_UNSUPPORTED";
+    GLEnum2[GLEnum2["FRAMEBUFFER_BINDING"] = 36006] = "FRAMEBUFFER_BINDING";
+    GLEnum2[GLEnum2["RENDERBUFFER_BINDING"] = 36007] = "RENDERBUFFER_BINDING";
+    GLEnum2[GLEnum2["READ_FRAMEBUFFER"] = 36008] = "READ_FRAMEBUFFER";
+    GLEnum2[GLEnum2["DRAW_FRAMEBUFFER"] = 36009] = "DRAW_FRAMEBUFFER";
+    GLEnum2[GLEnum2["MAX_RENDERBUFFER_SIZE"] = 34024] = "MAX_RENDERBUFFER_SIZE";
+    GLEnum2[GLEnum2["INVALID_FRAMEBUFFER_OPERATION"] = 1286] = "INVALID_FRAMEBUFFER_OPERATION";
+    GLEnum2[GLEnum2["UNPACK_FLIP_Y_WEBGL"] = 37440] = "UNPACK_FLIP_Y_WEBGL";
+    GLEnum2[GLEnum2["UNPACK_PREMULTIPLY_ALPHA_WEBGL"] = 37441] = "UNPACK_PREMULTIPLY_ALPHA_WEBGL";
+    GLEnum2[GLEnum2["UNPACK_COLORSPACE_CONVERSION_WEBGL"] = 37443] = "UNPACK_COLORSPACE_CONVERSION_WEBGL";
+    GLEnum2[GLEnum2["READ_BUFFER"] = 3074] = "READ_BUFFER";
+    GLEnum2[GLEnum2["UNPACK_ROW_LENGTH"] = 3314] = "UNPACK_ROW_LENGTH";
+    GLEnum2[GLEnum2["UNPACK_SKIP_ROWS"] = 3315] = "UNPACK_SKIP_ROWS";
+    GLEnum2[GLEnum2["UNPACK_SKIP_PIXELS"] = 3316] = "UNPACK_SKIP_PIXELS";
+    GLEnum2[GLEnum2["PACK_ROW_LENGTH"] = 3330] = "PACK_ROW_LENGTH";
+    GLEnum2[GLEnum2["PACK_SKIP_ROWS"] = 3331] = "PACK_SKIP_ROWS";
+    GLEnum2[GLEnum2["PACK_SKIP_PIXELS"] = 3332] = "PACK_SKIP_PIXELS";
+    GLEnum2[GLEnum2["TEXTURE_BINDING_3D"] = 32874] = "TEXTURE_BINDING_3D";
+    GLEnum2[GLEnum2["UNPACK_SKIP_IMAGES"] = 32877] = "UNPACK_SKIP_IMAGES";
+    GLEnum2[GLEnum2["UNPACK_IMAGE_HEIGHT"] = 32878] = "UNPACK_IMAGE_HEIGHT";
+    GLEnum2[GLEnum2["MAX_3D_TEXTURE_SIZE"] = 32883] = "MAX_3D_TEXTURE_SIZE";
+    GLEnum2[GLEnum2["MAX_ELEMENTS_VERTICES"] = 33e3] = "MAX_ELEMENTS_VERTICES";
+    GLEnum2[GLEnum2["MAX_ELEMENTS_INDICES"] = 33001] = "MAX_ELEMENTS_INDICES";
+    GLEnum2[GLEnum2["MAX_TEXTURE_LOD_BIAS"] = 34045] = "MAX_TEXTURE_LOD_BIAS";
+    GLEnum2[GLEnum2["MAX_FRAGMENT_UNIFORM_COMPONENTS"] = 35657] = "MAX_FRAGMENT_UNIFORM_COMPONENTS";
+    GLEnum2[GLEnum2["MAX_VERTEX_UNIFORM_COMPONENTS"] = 35658] = "MAX_VERTEX_UNIFORM_COMPONENTS";
+    GLEnum2[GLEnum2["MAX_ARRAY_TEXTURE_LAYERS"] = 35071] = "MAX_ARRAY_TEXTURE_LAYERS";
+    GLEnum2[GLEnum2["MIN_PROGRAM_TEXEL_OFFSET"] = 35076] = "MIN_PROGRAM_TEXEL_OFFSET";
+    GLEnum2[GLEnum2["MAX_PROGRAM_TEXEL_OFFSET"] = 35077] = "MAX_PROGRAM_TEXEL_OFFSET";
+    GLEnum2[GLEnum2["MAX_VARYING_COMPONENTS"] = 35659] = "MAX_VARYING_COMPONENTS";
+    GLEnum2[GLEnum2["FRAGMENT_SHADER_DERIVATIVE_HINT"] = 35723] = "FRAGMENT_SHADER_DERIVATIVE_HINT";
+    GLEnum2[GLEnum2["RASTERIZER_DISCARD"] = 35977] = "RASTERIZER_DISCARD";
+    GLEnum2[GLEnum2["VERTEX_ARRAY_BINDING"] = 34229] = "VERTEX_ARRAY_BINDING";
+    GLEnum2[GLEnum2["MAX_VERTEX_OUTPUT_COMPONENTS"] = 37154] = "MAX_VERTEX_OUTPUT_COMPONENTS";
+    GLEnum2[GLEnum2["MAX_FRAGMENT_INPUT_COMPONENTS"] = 37157] = "MAX_FRAGMENT_INPUT_COMPONENTS";
+    GLEnum2[GLEnum2["MAX_SERVER_WAIT_TIMEOUT"] = 37137] = "MAX_SERVER_WAIT_TIMEOUT";
+    GLEnum2[GLEnum2["MAX_ELEMENT_INDEX"] = 36203] = "MAX_ELEMENT_INDEX";
+    GLEnum2[GLEnum2["RED"] = 6403] = "RED";
+    GLEnum2[GLEnum2["RGB8"] = 32849] = "RGB8";
+    GLEnum2[GLEnum2["RGBA8"] = 32856] = "RGBA8";
+    GLEnum2[GLEnum2["RGB10_A2"] = 32857] = "RGB10_A2";
+    GLEnum2[GLEnum2["TEXTURE_3D"] = 32879] = "TEXTURE_3D";
+    GLEnum2[GLEnum2["TEXTURE_WRAP_R"] = 32882] = "TEXTURE_WRAP_R";
+    GLEnum2[GLEnum2["TEXTURE_MIN_LOD"] = 33082] = "TEXTURE_MIN_LOD";
+    GLEnum2[GLEnum2["TEXTURE_MAX_LOD"] = 33083] = "TEXTURE_MAX_LOD";
+    GLEnum2[GLEnum2["TEXTURE_BASE_LEVEL"] = 33084] = "TEXTURE_BASE_LEVEL";
+    GLEnum2[GLEnum2["TEXTURE_MAX_LEVEL"] = 33085] = "TEXTURE_MAX_LEVEL";
+    GLEnum2[GLEnum2["TEXTURE_COMPARE_MODE"] = 34892] = "TEXTURE_COMPARE_MODE";
+    GLEnum2[GLEnum2["TEXTURE_COMPARE_FUNC"] = 34893] = "TEXTURE_COMPARE_FUNC";
+    GLEnum2[GLEnum2["SRGB"] = 35904] = "SRGB";
+    GLEnum2[GLEnum2["SRGB8"] = 35905] = "SRGB8";
+    GLEnum2[GLEnum2["SRGB8_ALPHA8"] = 35907] = "SRGB8_ALPHA8";
+    GLEnum2[GLEnum2["COMPARE_REF_TO_TEXTURE"] = 34894] = "COMPARE_REF_TO_TEXTURE";
+    GLEnum2[GLEnum2["RGBA32F"] = 34836] = "RGBA32F";
+    GLEnum2[GLEnum2["RGB32F"] = 34837] = "RGB32F";
+    GLEnum2[GLEnum2["RGBA16F"] = 34842] = "RGBA16F";
+    GLEnum2[GLEnum2["RGB16F"] = 34843] = "RGB16F";
+    GLEnum2[GLEnum2["TEXTURE_2D_ARRAY"] = 35866] = "TEXTURE_2D_ARRAY";
+    GLEnum2[GLEnum2["TEXTURE_BINDING_2D_ARRAY"] = 35869] = "TEXTURE_BINDING_2D_ARRAY";
+    GLEnum2[GLEnum2["R11F_G11F_B10F"] = 35898] = "R11F_G11F_B10F";
+    GLEnum2[GLEnum2["RGB9_E5"] = 35901] = "RGB9_E5";
+    GLEnum2[GLEnum2["RGBA32UI"] = 36208] = "RGBA32UI";
+    GLEnum2[GLEnum2["RGB32UI"] = 36209] = "RGB32UI";
+    GLEnum2[GLEnum2["RGBA16UI"] = 36214] = "RGBA16UI";
+    GLEnum2[GLEnum2["RGB16UI"] = 36215] = "RGB16UI";
+    GLEnum2[GLEnum2["RGBA8UI"] = 36220] = "RGBA8UI";
+    GLEnum2[GLEnum2["RGB8UI"] = 36221] = "RGB8UI";
+    GLEnum2[GLEnum2["RGBA32I"] = 36226] = "RGBA32I";
+    GLEnum2[GLEnum2["RGB32I"] = 36227] = "RGB32I";
+    GLEnum2[GLEnum2["RGBA16I"] = 36232] = "RGBA16I";
+    GLEnum2[GLEnum2["RGB16I"] = 36233] = "RGB16I";
+    GLEnum2[GLEnum2["RGBA8I"] = 36238] = "RGBA8I";
+    GLEnum2[GLEnum2["RGB8I"] = 36239] = "RGB8I";
+    GLEnum2[GLEnum2["RED_INTEGER"] = 36244] = "RED_INTEGER";
+    GLEnum2[GLEnum2["RGB_INTEGER"] = 36248] = "RGB_INTEGER";
+    GLEnum2[GLEnum2["RGBA_INTEGER"] = 36249] = "RGBA_INTEGER";
+    GLEnum2[GLEnum2["R8"] = 33321] = "R8";
+    GLEnum2[GLEnum2["RG8"] = 33323] = "RG8";
+    GLEnum2[GLEnum2["R16F"] = 33325] = "R16F";
+    GLEnum2[GLEnum2["R32F"] = 33326] = "R32F";
+    GLEnum2[GLEnum2["RG16F"] = 33327] = "RG16F";
+    GLEnum2[GLEnum2["RG32F"] = 33328] = "RG32F";
+    GLEnum2[GLEnum2["R8I"] = 33329] = "R8I";
+    GLEnum2[GLEnum2["R8UI"] = 33330] = "R8UI";
+    GLEnum2[GLEnum2["R16I"] = 33331] = "R16I";
+    GLEnum2[GLEnum2["R16UI"] = 33332] = "R16UI";
+    GLEnum2[GLEnum2["R32I"] = 33333] = "R32I";
+    GLEnum2[GLEnum2["R32UI"] = 33334] = "R32UI";
+    GLEnum2[GLEnum2["RG8I"] = 33335] = "RG8I";
+    GLEnum2[GLEnum2["RG8UI"] = 33336] = "RG8UI";
+    GLEnum2[GLEnum2["RG16I"] = 33337] = "RG16I";
+    GLEnum2[GLEnum2["RG16UI"] = 33338] = "RG16UI";
+    GLEnum2[GLEnum2["RG32I"] = 33339] = "RG32I";
+    GLEnum2[GLEnum2["RG32UI"] = 33340] = "RG32UI";
+    GLEnum2[GLEnum2["R8_SNORM"] = 36756] = "R8_SNORM";
+    GLEnum2[GLEnum2["RG8_SNORM"] = 36757] = "RG8_SNORM";
+    GLEnum2[GLEnum2["RGB8_SNORM"] = 36758] = "RGB8_SNORM";
+    GLEnum2[GLEnum2["RGBA8_SNORM"] = 36759] = "RGBA8_SNORM";
+    GLEnum2[GLEnum2["RGB10_A2UI"] = 36975] = "RGB10_A2UI";
+    GLEnum2[GLEnum2["TEXTURE_IMMUTABLE_FORMAT"] = 37167] = "TEXTURE_IMMUTABLE_FORMAT";
+    GLEnum2[GLEnum2["TEXTURE_IMMUTABLE_LEVELS"] = 33503] = "TEXTURE_IMMUTABLE_LEVELS";
+    GLEnum2[GLEnum2["UNSIGNED_INT_2_10_10_10_REV"] = 33640] = "UNSIGNED_INT_2_10_10_10_REV";
+    GLEnum2[GLEnum2["UNSIGNED_INT_10F_11F_11F_REV"] = 35899] = "UNSIGNED_INT_10F_11F_11F_REV";
+    GLEnum2[GLEnum2["UNSIGNED_INT_5_9_9_9_REV"] = 35902] = "UNSIGNED_INT_5_9_9_9_REV";
+    GLEnum2[GLEnum2["FLOAT_32_UNSIGNED_INT_24_8_REV"] = 36269] = "FLOAT_32_UNSIGNED_INT_24_8_REV";
+    GLEnum2[GLEnum2["UNSIGNED_INT_24_8"] = 34042] = "UNSIGNED_INT_24_8";
+    GLEnum2[GLEnum2["HALF_FLOAT"] = 5131] = "HALF_FLOAT";
+    GLEnum2[GLEnum2["RG"] = 33319] = "RG";
+    GLEnum2[GLEnum2["RG_INTEGER"] = 33320] = "RG_INTEGER";
+    GLEnum2[GLEnum2["INT_2_10_10_10_REV"] = 36255] = "INT_2_10_10_10_REV";
+    GLEnum2[GLEnum2["CURRENT_QUERY"] = 34917] = "CURRENT_QUERY";
+    GLEnum2[GLEnum2["QUERY_RESULT"] = 34918] = "QUERY_RESULT";
+    GLEnum2[GLEnum2["QUERY_RESULT_AVAILABLE"] = 34919] = "QUERY_RESULT_AVAILABLE";
+    GLEnum2[GLEnum2["ANY_SAMPLES_PASSED"] = 35887] = "ANY_SAMPLES_PASSED";
+    GLEnum2[GLEnum2["ANY_SAMPLES_PASSED_CONSERVATIVE"] = 36202] = "ANY_SAMPLES_PASSED_CONSERVATIVE";
+    GLEnum2[GLEnum2["MAX_DRAW_BUFFERS"] = 34852] = "MAX_DRAW_BUFFERS";
+    GLEnum2[GLEnum2["DRAW_BUFFER0"] = 34853] = "DRAW_BUFFER0";
+    GLEnum2[GLEnum2["DRAW_BUFFER1"] = 34854] = "DRAW_BUFFER1";
+    GLEnum2[GLEnum2["DRAW_BUFFER2"] = 34855] = "DRAW_BUFFER2";
+    GLEnum2[GLEnum2["DRAW_BUFFER3"] = 34856] = "DRAW_BUFFER3";
+    GLEnum2[GLEnum2["DRAW_BUFFER4"] = 34857] = "DRAW_BUFFER4";
+    GLEnum2[GLEnum2["DRAW_BUFFER5"] = 34858] = "DRAW_BUFFER5";
+    GLEnum2[GLEnum2["DRAW_BUFFER6"] = 34859] = "DRAW_BUFFER6";
+    GLEnum2[GLEnum2["DRAW_BUFFER7"] = 34860] = "DRAW_BUFFER7";
+    GLEnum2[GLEnum2["DRAW_BUFFER8"] = 34861] = "DRAW_BUFFER8";
+    GLEnum2[GLEnum2["DRAW_BUFFER9"] = 34862] = "DRAW_BUFFER9";
+    GLEnum2[GLEnum2["DRAW_BUFFER10"] = 34863] = "DRAW_BUFFER10";
+    GLEnum2[GLEnum2["DRAW_BUFFER11"] = 34864] = "DRAW_BUFFER11";
+    GLEnum2[GLEnum2["DRAW_BUFFER12"] = 34865] = "DRAW_BUFFER12";
+    GLEnum2[GLEnum2["DRAW_BUFFER13"] = 34866] = "DRAW_BUFFER13";
+    GLEnum2[GLEnum2["DRAW_BUFFER14"] = 34867] = "DRAW_BUFFER14";
+    GLEnum2[GLEnum2["DRAW_BUFFER15"] = 34868] = "DRAW_BUFFER15";
+    GLEnum2[GLEnum2["MAX_COLOR_ATTACHMENTS"] = 36063] = "MAX_COLOR_ATTACHMENTS";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT1"] = 36065] = "COLOR_ATTACHMENT1";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT2"] = 36066] = "COLOR_ATTACHMENT2";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT3"] = 36067] = "COLOR_ATTACHMENT3";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT4"] = 36068] = "COLOR_ATTACHMENT4";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT5"] = 36069] = "COLOR_ATTACHMENT5";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT6"] = 36070] = "COLOR_ATTACHMENT6";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT7"] = 36071] = "COLOR_ATTACHMENT7";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT8"] = 36072] = "COLOR_ATTACHMENT8";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT9"] = 36073] = "COLOR_ATTACHMENT9";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT10"] = 36074] = "COLOR_ATTACHMENT10";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT11"] = 36075] = "COLOR_ATTACHMENT11";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT12"] = 36076] = "COLOR_ATTACHMENT12";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT13"] = 36077] = "COLOR_ATTACHMENT13";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT14"] = 36078] = "COLOR_ATTACHMENT14";
+    GLEnum2[GLEnum2["COLOR_ATTACHMENT15"] = 36079] = "COLOR_ATTACHMENT15";
+    GLEnum2[GLEnum2["SAMPLER_3D"] = 35679] = "SAMPLER_3D";
+    GLEnum2[GLEnum2["SAMPLER_2D_SHADOW"] = 35682] = "SAMPLER_2D_SHADOW";
+    GLEnum2[GLEnum2["SAMPLER_2D_ARRAY"] = 36289] = "SAMPLER_2D_ARRAY";
+    GLEnum2[GLEnum2["SAMPLER_2D_ARRAY_SHADOW"] = 36292] = "SAMPLER_2D_ARRAY_SHADOW";
+    GLEnum2[GLEnum2["SAMPLER_CUBE_SHADOW"] = 36293] = "SAMPLER_CUBE_SHADOW";
+    GLEnum2[GLEnum2["INT_SAMPLER_2D"] = 36298] = "INT_SAMPLER_2D";
+    GLEnum2[GLEnum2["INT_SAMPLER_3D"] = 36299] = "INT_SAMPLER_3D";
+    GLEnum2[GLEnum2["INT_SAMPLER_CUBE"] = 36300] = "INT_SAMPLER_CUBE";
+    GLEnum2[GLEnum2["INT_SAMPLER_2D_ARRAY"] = 36303] = "INT_SAMPLER_2D_ARRAY";
+    GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_2D"] = 36306] = "UNSIGNED_INT_SAMPLER_2D";
+    GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_3D"] = 36307] = "UNSIGNED_INT_SAMPLER_3D";
+    GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_CUBE"] = 36308] = "UNSIGNED_INT_SAMPLER_CUBE";
+    GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_2D_ARRAY"] = 36311] = "UNSIGNED_INT_SAMPLER_2D_ARRAY";
+    GLEnum2[GLEnum2["MAX_SAMPLES"] = 36183] = "MAX_SAMPLES";
+    GLEnum2[GLEnum2["SAMPLER_BINDING"] = 35097] = "SAMPLER_BINDING";
+    GLEnum2[GLEnum2["PIXEL_PACK_BUFFER"] = 35051] = "PIXEL_PACK_BUFFER";
+    GLEnum2[GLEnum2["PIXEL_UNPACK_BUFFER"] = 35052] = "PIXEL_UNPACK_BUFFER";
+    GLEnum2[GLEnum2["PIXEL_PACK_BUFFER_BINDING"] = 35053] = "PIXEL_PACK_BUFFER_BINDING";
+    GLEnum2[GLEnum2["PIXEL_UNPACK_BUFFER_BINDING"] = 35055] = "PIXEL_UNPACK_BUFFER_BINDING";
+    GLEnum2[GLEnum2["COPY_READ_BUFFER"] = 36662] = "COPY_READ_BUFFER";
+    GLEnum2[GLEnum2["COPY_WRITE_BUFFER"] = 36663] = "COPY_WRITE_BUFFER";
+    GLEnum2[GLEnum2["COPY_READ_BUFFER_BINDING"] = 36662] = "COPY_READ_BUFFER_BINDING";
+    GLEnum2[GLEnum2["COPY_WRITE_BUFFER_BINDING"] = 36663] = "COPY_WRITE_BUFFER_BINDING";
+    GLEnum2[GLEnum2["FLOAT_MAT2x3"] = 35685] = "FLOAT_MAT2x3";
+    GLEnum2[GLEnum2["FLOAT_MAT2x4"] = 35686] = "FLOAT_MAT2x4";
+    GLEnum2[GLEnum2["FLOAT_MAT3x2"] = 35687] = "FLOAT_MAT3x2";
+    GLEnum2[GLEnum2["FLOAT_MAT3x4"] = 35688] = "FLOAT_MAT3x4";
+    GLEnum2[GLEnum2["FLOAT_MAT4x2"] = 35689] = "FLOAT_MAT4x2";
+    GLEnum2[GLEnum2["FLOAT_MAT4x3"] = 35690] = "FLOAT_MAT4x3";
+    GLEnum2[GLEnum2["UNSIGNED_INT_VEC2"] = 36294] = "UNSIGNED_INT_VEC2";
+    GLEnum2[GLEnum2["UNSIGNED_INT_VEC3"] = 36295] = "UNSIGNED_INT_VEC3";
+    GLEnum2[GLEnum2["UNSIGNED_INT_VEC4"] = 36296] = "UNSIGNED_INT_VEC4";
+    GLEnum2[GLEnum2["UNSIGNED_NORMALIZED"] = 35863] = "UNSIGNED_NORMALIZED";
+    GLEnum2[GLEnum2["SIGNED_NORMALIZED"] = 36764] = "SIGNED_NORMALIZED";
+    GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_INTEGER"] = 35069] = "VERTEX_ATTRIB_ARRAY_INTEGER";
+    GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_DIVISOR"] = 35070] = "VERTEX_ATTRIB_ARRAY_DIVISOR";
+    GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_MODE"] = 35967] = "TRANSFORM_FEEDBACK_BUFFER_MODE";
+    GLEnum2[GLEnum2["MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS"] = 35968] = "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS";
+    GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_VARYINGS"] = 35971] = "TRANSFORM_FEEDBACK_VARYINGS";
+    GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_START"] = 35972] = "TRANSFORM_FEEDBACK_BUFFER_START";
+    GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_SIZE"] = 35973] = "TRANSFORM_FEEDBACK_BUFFER_SIZE";
+    GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"] = 35976] = "TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN";
+    GLEnum2[GLEnum2["MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS"] = 35978] = "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS";
+    GLEnum2[GLEnum2["MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS"] = 35979] = "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS";
+    GLEnum2[GLEnum2["INTERLEAVED_ATTRIBS"] = 35980] = "INTERLEAVED_ATTRIBS";
+    GLEnum2[GLEnum2["SEPARATE_ATTRIBS"] = 35981] = "SEPARATE_ATTRIBS";
+    GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER"] = 35982] = "TRANSFORM_FEEDBACK_BUFFER";
+    GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_BINDING"] = 35983] = "TRANSFORM_FEEDBACK_BUFFER_BINDING";
+    GLEnum2[GLEnum2["TRANSFORM_FEEDBACK"] = 36386] = "TRANSFORM_FEEDBACK";
+    GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_PAUSED"] = 36387] = "TRANSFORM_FEEDBACK_PAUSED";
+    GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_ACTIVE"] = 36388] = "TRANSFORM_FEEDBACK_ACTIVE";
+    GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BINDING"] = 36389] = "TRANSFORM_FEEDBACK_BINDING";
+    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING"] = 33296] = "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING";
+    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"] = 33297] = "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE";
+    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_RED_SIZE"] = 33298] = "FRAMEBUFFER_ATTACHMENT_RED_SIZE";
+    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_GREEN_SIZE"] = 33299] = "FRAMEBUFFER_ATTACHMENT_GREEN_SIZE";
+    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_BLUE_SIZE"] = 33300] = "FRAMEBUFFER_ATTACHMENT_BLUE_SIZE";
+    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE"] = 33301] = "FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE";
+    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE"] = 33302] = "FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE";
+    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE"] = 33303] = "FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE";
+    GLEnum2[GLEnum2["FRAMEBUFFER_DEFAULT"] = 33304] = "FRAMEBUFFER_DEFAULT";
+    GLEnum2[GLEnum2["DEPTH24_STENCIL8"] = 35056] = "DEPTH24_STENCIL8";
+    GLEnum2[GLEnum2["DRAW_FRAMEBUFFER_BINDING"] = 36006] = "DRAW_FRAMEBUFFER_BINDING";
+    GLEnum2[GLEnum2["READ_FRAMEBUFFER_BINDING"] = 36010] = "READ_FRAMEBUFFER_BINDING";
+    GLEnum2[GLEnum2["RENDERBUFFER_SAMPLES"] = 36011] = "RENDERBUFFER_SAMPLES";
+    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER"] = 36052] = "FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER";
+    GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"] = 36182] = "FRAMEBUFFER_INCOMPLETE_MULTISAMPLE";
+    GLEnum2[GLEnum2["UNIFORM_BUFFER"] = 35345] = "UNIFORM_BUFFER";
+    GLEnum2[GLEnum2["UNIFORM_BUFFER_BINDING"] = 35368] = "UNIFORM_BUFFER_BINDING";
+    GLEnum2[GLEnum2["UNIFORM_BUFFER_START"] = 35369] = "UNIFORM_BUFFER_START";
+    GLEnum2[GLEnum2["UNIFORM_BUFFER_SIZE"] = 35370] = "UNIFORM_BUFFER_SIZE";
+    GLEnum2[GLEnum2["MAX_VERTEX_UNIFORM_BLOCKS"] = 35371] = "MAX_VERTEX_UNIFORM_BLOCKS";
+    GLEnum2[GLEnum2["MAX_FRAGMENT_UNIFORM_BLOCKS"] = 35373] = "MAX_FRAGMENT_UNIFORM_BLOCKS";
+    GLEnum2[GLEnum2["MAX_COMBINED_UNIFORM_BLOCKS"] = 35374] = "MAX_COMBINED_UNIFORM_BLOCKS";
+    GLEnum2[GLEnum2["MAX_UNIFORM_BUFFER_BINDINGS"] = 35375] = "MAX_UNIFORM_BUFFER_BINDINGS";
+    GLEnum2[GLEnum2["MAX_UNIFORM_BLOCK_SIZE"] = 35376] = "MAX_UNIFORM_BLOCK_SIZE";
+    GLEnum2[GLEnum2["MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS"] = 35377] = "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS";
+    GLEnum2[GLEnum2["MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS"] = 35379] = "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS";
+    GLEnum2[GLEnum2["UNIFORM_BUFFER_OFFSET_ALIGNMENT"] = 35380] = "UNIFORM_BUFFER_OFFSET_ALIGNMENT";
+    GLEnum2[GLEnum2["ACTIVE_UNIFORM_BLOCKS"] = 35382] = "ACTIVE_UNIFORM_BLOCKS";
+    GLEnum2[GLEnum2["UNIFORM_TYPE"] = 35383] = "UNIFORM_TYPE";
+    GLEnum2[GLEnum2["UNIFORM_SIZE"] = 35384] = "UNIFORM_SIZE";
+    GLEnum2[GLEnum2["UNIFORM_BLOCK_INDEX"] = 35386] = "UNIFORM_BLOCK_INDEX";
+    GLEnum2[GLEnum2["UNIFORM_OFFSET"] = 35387] = "UNIFORM_OFFSET";
+    GLEnum2[GLEnum2["UNIFORM_ARRAY_STRIDE"] = 35388] = "UNIFORM_ARRAY_STRIDE";
+    GLEnum2[GLEnum2["UNIFORM_MATRIX_STRIDE"] = 35389] = "UNIFORM_MATRIX_STRIDE";
+    GLEnum2[GLEnum2["UNIFORM_IS_ROW_MAJOR"] = 35390] = "UNIFORM_IS_ROW_MAJOR";
+    GLEnum2[GLEnum2["UNIFORM_BLOCK_BINDING"] = 35391] = "UNIFORM_BLOCK_BINDING";
+    GLEnum2[GLEnum2["UNIFORM_BLOCK_DATA_SIZE"] = 35392] = "UNIFORM_BLOCK_DATA_SIZE";
+    GLEnum2[GLEnum2["UNIFORM_BLOCK_ACTIVE_UNIFORMS"] = 35394] = "UNIFORM_BLOCK_ACTIVE_UNIFORMS";
+    GLEnum2[GLEnum2["UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES"] = 35395] = "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES";
+    GLEnum2[GLEnum2["UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER"] = 35396] = "UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER";
+    GLEnum2[GLEnum2["UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"] = 35398] = "UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER";
+    GLEnum2[GLEnum2["OBJECT_TYPE"] = 37138] = "OBJECT_TYPE";
+    GLEnum2[GLEnum2["SYNC_CONDITION"] = 37139] = "SYNC_CONDITION";
+    GLEnum2[GLEnum2["SYNC_STATUS"] = 37140] = "SYNC_STATUS";
+    GLEnum2[GLEnum2["SYNC_FLAGS"] = 37141] = "SYNC_FLAGS";
+    GLEnum2[GLEnum2["SYNC_FENCE"] = 37142] = "SYNC_FENCE";
+    GLEnum2[GLEnum2["SYNC_GPU_COMMANDS_COMPLETE"] = 37143] = "SYNC_GPU_COMMANDS_COMPLETE";
+    GLEnum2[GLEnum2["UNSIGNALED"] = 37144] = "UNSIGNALED";
+    GLEnum2[GLEnum2["SIGNALED"] = 37145] = "SIGNALED";
+    GLEnum2[GLEnum2["ALREADY_SIGNALED"] = 37146] = "ALREADY_SIGNALED";
+    GLEnum2[GLEnum2["TIMEOUT_EXPIRED"] = 37147] = "TIMEOUT_EXPIRED";
+    GLEnum2[GLEnum2["CONDITION_SATISFIED"] = 37148] = "CONDITION_SATISFIED";
+    GLEnum2[GLEnum2["WAIT_FAILED"] = 37149] = "WAIT_FAILED";
+    GLEnum2[GLEnum2["SYNC_FLUSH_COMMANDS_BIT"] = 1] = "SYNC_FLUSH_COMMANDS_BIT";
+    GLEnum2[GLEnum2["COLOR"] = 6144] = "COLOR";
+    GLEnum2[GLEnum2["DEPTH"] = 6145] = "DEPTH";
+    GLEnum2[GLEnum2["STENCIL"] = 6146] = "STENCIL";
+    GLEnum2[GLEnum2["MIN"] = 32775] = "MIN";
+    GLEnum2[GLEnum2["MAX"] = 32776] = "MAX";
+    GLEnum2[GLEnum2["DEPTH_COMPONENT24"] = 33190] = "DEPTH_COMPONENT24";
+    GLEnum2[GLEnum2["STREAM_READ"] = 35041] = "STREAM_READ";
+    GLEnum2[GLEnum2["STREAM_COPY"] = 35042] = "STREAM_COPY";
+    GLEnum2[GLEnum2["STATIC_READ"] = 35045] = "STATIC_READ";
+    GLEnum2[GLEnum2["STATIC_COPY"] = 35046] = "STATIC_COPY";
+    GLEnum2[GLEnum2["DYNAMIC_READ"] = 35049] = "DYNAMIC_READ";
+    GLEnum2[GLEnum2["DYNAMIC_COPY"] = 35050] = "DYNAMIC_COPY";
+    GLEnum2[GLEnum2["DEPTH_COMPONENT32F"] = 36012] = "DEPTH_COMPONENT32F";
+    GLEnum2[GLEnum2["DEPTH32F_STENCIL8"] = 36013] = "DEPTH32F_STENCIL8";
+    GLEnum2[GLEnum2["INVALID_INDEX"] = 4294967295] = "INVALID_INDEX";
+    GLEnum2[GLEnum2["TIMEOUT_IGNORED"] = -1] = "TIMEOUT_IGNORED";
+    GLEnum2[GLEnum2["MAX_CLIENT_WAIT_TIMEOUT_WEBGL"] = 37447] = "MAX_CLIENT_WAIT_TIMEOUT_WEBGL";
+    GLEnum2[GLEnum2["UNMASKED_VENDOR_WEBGL"] = 37445] = "UNMASKED_VENDOR_WEBGL";
+    GLEnum2[GLEnum2["UNMASKED_RENDERER_WEBGL"] = 37446] = "UNMASKED_RENDERER_WEBGL";
+    GLEnum2[GLEnum2["MAX_TEXTURE_MAX_ANISOTROPY_EXT"] = 34047] = "MAX_TEXTURE_MAX_ANISOTROPY_EXT";
+    GLEnum2[GLEnum2["TEXTURE_MAX_ANISOTROPY_EXT"] = 34046] = "TEXTURE_MAX_ANISOTROPY_EXT";
+    GLEnum2[GLEnum2["R16_EXT"] = 33322] = "R16_EXT";
+    GLEnum2[GLEnum2["RG16_EXT"] = 33324] = "RG16_EXT";
+    GLEnum2[GLEnum2["RGB16_EXT"] = 32852] = "RGB16_EXT";
+    GLEnum2[GLEnum2["RGBA16_EXT"] = 32859] = "RGBA16_EXT";
+    GLEnum2[GLEnum2["R16_SNORM_EXT"] = 36760] = "R16_SNORM_EXT";
+    GLEnum2[GLEnum2["RG16_SNORM_EXT"] = 36761] = "RG16_SNORM_EXT";
+    GLEnum2[GLEnum2["RGB16_SNORM_EXT"] = 36762] = "RGB16_SNORM_EXT";
+    GLEnum2[GLEnum2["RGBA16_SNORM_EXT"] = 36763] = "RGBA16_SNORM_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_RGB_S3TC_DXT1_EXT"] = 33776] = "COMPRESSED_RGB_S3TC_DXT1_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_S3TC_DXT1_EXT"] = 33777] = "COMPRESSED_RGBA_S3TC_DXT1_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_S3TC_DXT3_EXT"] = 33778] = "COMPRESSED_RGBA_S3TC_DXT3_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_S3TC_DXT5_EXT"] = 33779] = "COMPRESSED_RGBA_S3TC_DXT5_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB_S3TC_DXT1_EXT"] = 35916] = "COMPRESSED_SRGB_S3TC_DXT1_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"] = 35917] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"] = 35918] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"] = 35919] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_RED_RGTC1_EXT"] = 36283] = "COMPRESSED_RED_RGTC1_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_SIGNED_RED_RGTC1_EXT"] = 36284] = "COMPRESSED_SIGNED_RED_RGTC1_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_RED_GREEN_RGTC2_EXT"] = 36285] = "COMPRESSED_RED_GREEN_RGTC2_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT"] = 36286] = "COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_BPTC_UNORM_EXT"] = 36492] = "COMPRESSED_RGBA_BPTC_UNORM_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT"] = 36493] = "COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT"] = 36494] = "COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT"] = 36495] = "COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT";
+    GLEnum2[GLEnum2["COMPRESSED_R11_EAC"] = 37488] = "COMPRESSED_R11_EAC";
+    GLEnum2[GLEnum2["COMPRESSED_SIGNED_R11_EAC"] = 37489] = "COMPRESSED_SIGNED_R11_EAC";
+    GLEnum2[GLEnum2["COMPRESSED_RG11_EAC"] = 37490] = "COMPRESSED_RG11_EAC";
+    GLEnum2[GLEnum2["COMPRESSED_SIGNED_RG11_EAC"] = 37491] = "COMPRESSED_SIGNED_RG11_EAC";
+    GLEnum2[GLEnum2["COMPRESSED_RGB8_ETC2"] = 37492] = "COMPRESSED_RGB8_ETC2";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA8_ETC2_EAC"] = 37493] = "COMPRESSED_RGBA8_ETC2_EAC";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ETC2"] = 37494] = "COMPRESSED_SRGB8_ETC2";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"] = 37495] = "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC";
+    GLEnum2[GLEnum2["COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37496] = "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37497] = "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2";
+    GLEnum2[GLEnum2["COMPRESSED_RGB_PVRTC_4BPPV1_IMG"] = 35840] = "COMPRESSED_RGB_PVRTC_4BPPV1_IMG";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"] = 35842] = "COMPRESSED_RGBA_PVRTC_4BPPV1_IMG";
+    GLEnum2[GLEnum2["COMPRESSED_RGB_PVRTC_2BPPV1_IMG"] = 35841] = "COMPRESSED_RGB_PVRTC_2BPPV1_IMG";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"] = 35843] = "COMPRESSED_RGBA_PVRTC_2BPPV1_IMG";
+    GLEnum2[GLEnum2["COMPRESSED_RGB_ETC1_WEBGL"] = 36196] = "COMPRESSED_RGB_ETC1_WEBGL";
+    GLEnum2[GLEnum2["COMPRESSED_RGB_ATC_WEBGL"] = 35986] = "COMPRESSED_RGB_ATC_WEBGL";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL"] = 35986] = "COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL"] = 34798] = "COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_4x4_KHR"] = 37808] = "COMPRESSED_RGBA_ASTC_4x4_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_5x4_KHR"] = 37809] = "COMPRESSED_RGBA_ASTC_5x4_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_5x5_KHR"] = 37810] = "COMPRESSED_RGBA_ASTC_5x5_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_6x5_KHR"] = 37811] = "COMPRESSED_RGBA_ASTC_6x5_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_6x6_KHR"] = 37812] = "COMPRESSED_RGBA_ASTC_6x6_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_8x5_KHR"] = 37813] = "COMPRESSED_RGBA_ASTC_8x5_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_8x6_KHR"] = 37814] = "COMPRESSED_RGBA_ASTC_8x6_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_8x8_KHR"] = 37815] = "COMPRESSED_RGBA_ASTC_8x8_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x5_KHR"] = 37816] = "COMPRESSED_RGBA_ASTC_10x5_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x6_KHR"] = 37817] = "COMPRESSED_RGBA_ASTC_10x6_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x8_KHR"] = 37818] = "COMPRESSED_RGBA_ASTC_10x8_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x10_KHR"] = 37819] = "COMPRESSED_RGBA_ASTC_10x10_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_12x10_KHR"] = 37820] = "COMPRESSED_RGBA_ASTC_12x10_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_12x12_KHR"] = 37821] = "COMPRESSED_RGBA_ASTC_12x12_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"] = 37840] = "COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"] = 37841] = "COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"] = 37842] = "COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"] = 37843] = "COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"] = 37844] = "COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"] = 37845] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"] = 37846] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"] = 37847] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"] = 37848] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"] = 37849] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"] = 37850] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"] = 37851] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"] = 37852] = "COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"] = 37853] = "COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR";
+    GLEnum2[GLEnum2["QUERY_COUNTER_BITS_EXT"] = 34916] = "QUERY_COUNTER_BITS_EXT";
+    GLEnum2[GLEnum2["CURRENT_QUERY_EXT"] = 34917] = "CURRENT_QUERY_EXT";
+    GLEnum2[GLEnum2["QUERY_RESULT_EXT"] = 34918] = "QUERY_RESULT_EXT";
+    GLEnum2[GLEnum2["QUERY_RESULT_AVAILABLE_EXT"] = 34919] = "QUERY_RESULT_AVAILABLE_EXT";
+    GLEnum2[GLEnum2["TIME_ELAPSED_EXT"] = 35007] = "TIME_ELAPSED_EXT";
+    GLEnum2[GLEnum2["TIMESTAMP_EXT"] = 36392] = "TIMESTAMP_EXT";
+    GLEnum2[GLEnum2["GPU_DISJOINT_EXT"] = 36795] = "GPU_DISJOINT_EXT";
+    GLEnum2[GLEnum2["COMPLETION_STATUS_KHR"] = 37297] = "COMPLETION_STATUS_KHR";
+    GLEnum2[GLEnum2["DEPTH_CLAMP_EXT"] = 34383] = "DEPTH_CLAMP_EXT";
+    GLEnum2[GLEnum2["FIRST_VERTEX_CONVENTION_WEBGL"] = 36429] = "FIRST_VERTEX_CONVENTION_WEBGL";
+    GLEnum2[GLEnum2["LAST_VERTEX_CONVENTION_WEBGL"] = 36430] = "LAST_VERTEX_CONVENTION_WEBGL";
+    GLEnum2[GLEnum2["PROVOKING_VERTEX_WEBL"] = 36431] = "PROVOKING_VERTEX_WEBL";
+    GLEnum2[GLEnum2["POLYGON_MODE_WEBGL"] = 2880] = "POLYGON_MODE_WEBGL";
+    GLEnum2[GLEnum2["POLYGON_OFFSET_LINE_WEBGL"] = 10754] = "POLYGON_OFFSET_LINE_WEBGL";
+    GLEnum2[GLEnum2["LINE_WEBGL"] = 6913] = "LINE_WEBGL";
+    GLEnum2[GLEnum2["FILL_WEBGL"] = 6914] = "FILL_WEBGL";
+    GLEnum2[GLEnum2["MAX_CLIP_DISTANCES_WEBGL"] = 3378] = "MAX_CLIP_DISTANCES_WEBGL";
+    GLEnum2[GLEnum2["MAX_CULL_DISTANCES_WEBGL"] = 33529] = "MAX_CULL_DISTANCES_WEBGL";
+    GLEnum2[GLEnum2["MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL"] = 33530] = "MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE0_WEBGL"] = 12288] = "CLIP_DISTANCE0_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE1_WEBGL"] = 12289] = "CLIP_DISTANCE1_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE2_WEBGL"] = 12290] = "CLIP_DISTANCE2_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE3_WEBGL"] = 12291] = "CLIP_DISTANCE3_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE4_WEBGL"] = 12292] = "CLIP_DISTANCE4_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE5_WEBGL"] = 12293] = "CLIP_DISTANCE5_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE6_WEBGL"] = 12294] = "CLIP_DISTANCE6_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE7_WEBGL"] = 12295] = "CLIP_DISTANCE7_WEBGL";
+    GLEnum2[GLEnum2["POLYGON_OFFSET_CLAMP_EXT"] = 36379] = "POLYGON_OFFSET_CLAMP_EXT";
+    GLEnum2[GLEnum2["LOWER_LEFT_EXT"] = 36001] = "LOWER_LEFT_EXT";
+    GLEnum2[GLEnum2["UPPER_LEFT_EXT"] = 36002] = "UPPER_LEFT_EXT";
+    GLEnum2[GLEnum2["NEGATIVE_ONE_TO_ONE_EXT"] = 37726] = "NEGATIVE_ONE_TO_ONE_EXT";
+    GLEnum2[GLEnum2["ZERO_TO_ONE_EXT"] = 37727] = "ZERO_TO_ONE_EXT";
+    GLEnum2[GLEnum2["CLIP_ORIGIN_EXT"] = 37724] = "CLIP_ORIGIN_EXT";
+    GLEnum2[GLEnum2["CLIP_DEPTH_MODE_EXT"] = 37725] = "CLIP_DEPTH_MODE_EXT";
+    GLEnum2[GLEnum2["SRC1_COLOR_WEBGL"] = 35065] = "SRC1_COLOR_WEBGL";
+    GLEnum2[GLEnum2["SRC1_ALPHA_WEBGL"] = 34185] = "SRC1_ALPHA_WEBGL";
+    GLEnum2[GLEnum2["ONE_MINUS_SRC1_COLOR_WEBGL"] = 35066] = "ONE_MINUS_SRC1_COLOR_WEBGL";
+    GLEnum2[GLEnum2["ONE_MINUS_SRC1_ALPHA_WEBGL"] = 35067] = "ONE_MINUS_SRC1_ALPHA_WEBGL";
+    GLEnum2[GLEnum2["MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL"] = 35068] = "MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL";
+    GLEnum2[GLEnum2["MIRROR_CLAMP_TO_EDGE_EXT"] = 34627] = "MIRROR_CLAMP_TO_EDGE_EXT";
+  })(GLEnum || (GLEnum = {}));
+
   // src/api/parse-map.ts
-  var import_core11 = __toESM(require_core());
+  var import_core11 = __toESM(require_core(), 1);
 
   // src/api/layer-map.ts
-  var import_moment_timezone = __toESM(require_moment_timezone2());
-  var import_aggregation_layers = __toESM(require_aggregation_layers());
-  var import_layers4 = __toESM(require_layers());
-  var import_geo_layers7 = __toESM(require_geo_layers());
+  var import_moment_timezone = __toESM(require_moment_timezone2(), 1);
+  var import_aggregation_layers = __toESM(require_aggregation_layers(), 1);
+  var import_layers4 = __toESM(require_layers(), 1);
+  var import_geo_layers7 = __toESM(require_geo_layers(), 1);
   var SCALE_FUNCS = {
     linear: linear2,
     ordinal,
@@ -13521,12 +13943,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     variance
   };
   var hexToRGBA = (c) => {
-    const {
-      r,
-      g,
-      b,
-      opacity
-    } = rgb(c);
+    const { r, g, b, opacity } = rgb(c);
     return [r, g, b, 255 * opacity];
   };
   var sharedPropMap = {
@@ -13557,12 +13974,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
   };
   var aggregationVisConfig = {
-    colorAggregation: (x) => ({
-      colorAggregation: AGGREGATION[x] || AGGREGATION.sum
-    }),
-    colorRange: (x) => ({
-      colorRange: x.colors.map(hexToRGBA)
-    }),
+    colorAggregation: (x) => ({ colorAggregation: AGGREGATION[x] || AGGREGATION.sum }),
+    colorRange: (x) => ({ colorRange: x.colors.map(hexToRGBA) }),
     coverage: "coverage",
     elevationPercentile: ["elevationLowerPercentile", "elevationUpperPercentile"],
     percentile: ["lowerPercentile", "upperPercentile"]
@@ -13575,14 +13988,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     wrapLongitude: false
   };
   function mergePropMaps(a = {}, b = {}) {
-    return {
-      ...a,
-      ...b,
-      visConfig: {
-        ...a.visConfig,
-        ...b.visConfig
-      }
-    };
+    return { ...a, ...b, visConfig: { ...a.visConfig, ...b.visConfig } };
   }
   function getLayer(type, config, dataset) {
     let basePropMap = sharedPropMap;
@@ -13600,15 +14006,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         Layer: import_layers4.GeoJsonLayer,
         propMap: {
           columns: {
-            altitude: (x) => ({
-              parameters: {
-                depthTest: Boolean(x)
-              }
-            })
+            altitude: (x) => ({ parameters: { depthTest: Boolean(x) } })
           },
-          visConfig: {
-            outline: "stroked"
-          }
+          visConfig: { outline: "stroked" }
         }
       },
       geojson: {
@@ -13616,55 +14016,23 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       },
       grid: {
         Layer: import_aggregation_layers.CPUGridLayer,
-        propMap: {
-          visConfig: {
-            ...aggregationVisConfig,
-            worldUnitSize: (x) => ({
-              cellSize: 1e3 * x
-            })
-          }
-        },
-        defaultProps: {
-          getPosition
-        }
+        propMap: { visConfig: { ...aggregationVisConfig, worldUnitSize: (x) => ({ cellSize: 1e3 * x }) } },
+        defaultProps: { getPosition }
       },
       heatmap: {
         Layer: import_aggregation_layers.HeatmapLayer,
-        propMap: {
-          visConfig: {
-            ...aggregationVisConfig,
-            radius: "radiusPixels"
-          }
-        },
-        defaultProps: {
-          getPosition
-        }
+        propMap: { visConfig: { ...aggregationVisConfig, radius: "radiusPixels" } },
+        defaultProps: { getPosition }
       },
       hexagon: {
         Layer: import_aggregation_layers.HexagonLayer,
-        propMap: {
-          visConfig: {
-            ...aggregationVisConfig,
-            worldUnitSize: (x) => ({
-              radius: 1e3 * x
-            })
-          }
-        },
-        defaultProps: {
-          getPosition
-        }
+        propMap: { visConfig: { ...aggregationVisConfig, worldUnitSize: (x) => ({ radius: 1e3 * x }) } },
+        defaultProps: { getPosition }
       },
       hexagonId: {
         Layer: import_geo_layers7.H3HexagonLayer,
-        propMap: {
-          visConfig: {
-            coverage: "coverage"
-          }
-        },
-        defaultProps: {
-          getHexagon: (d) => d[hexagonId],
-          stroked: false
-        }
+        propMap: { visConfig: { coverage: "coverage" } },
+        defaultProps: { getHexagon: (d) => d[hexagonId], stroked: false }
       }
     };
     const layer = layerTypeDefs[type];
@@ -13672,10 +14040,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     return {
       ...layer,
       propMap: mergePropMaps(basePropMap, layer.propMap),
-      defaultProps: {
-        ...defaultProps9,
-        ...layer.defaultProps
-      }
+      defaultProps: { ...defaultProps9, ...layer.defaultProps }
     };
   }
   function layerFromTileDataset(scheme, type) {
@@ -13694,21 +14059,15 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     const {
       aggregationExp,
       aggregationResLevel,
-      data: {
-        scheme
-      }
+      data: { scheme }
     } = dataset;
     return {
       Layer: layerFromTileDataset(scheme),
       propMap: basePropMap,
       defaultProps: {
         ...defaultProps9,
-        ...aggregationExp && {
-          aggregationExp
-        },
-        ...aggregationResLevel && {
-          aggregationResLevel
-        },
+        ...aggregationExp && { aggregationExp },
+        ...aggregationResLevel && { aggregationResLevel },
         uniqueIdProperty: "geoid"
       }
     };
@@ -13720,9 +14079,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (scaleType === "quantile" && attribute.quantiles) {
       return attribute.quantiles.global ? attribute.quantiles.global[scaleLength] : attribute.quantiles[scaleLength];
     }
-    let {
-      min: min2
-    } = attribute;
+    let { min: min2 } = attribute;
     if (scaleType === "log" && min2 === 0) {
       min2 = 1e-5;
     }
@@ -13730,7 +14087,11 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
   function domainFromValues(values, scaleType) {
     if (scaleType === "ordinal" || scaleType === "point") {
-      return groupSort(values, (g) => -g.length, (d) => d);
+      return groupSort(
+        values,
+        (g) => -g.length,
+        (d) => d
+      );
     } else if (scaleType === "quantile") {
       return values.sort((a, b) => a - b);
     } else if (scaleType === "log") {
@@ -13741,15 +14102,11 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
   function calculateDomain(data, name, scaleType, scaleLength) {
     if (data.tilestats) {
-      const {
-        attributes
-      } = data.tilestats.layers[0];
+      const { attributes } = data.tilestats.layers[0];
       const attribute = attributes.find((a) => a.attribute === name);
       return domainFromAttribute(attribute, scaleType, scaleLength);
     } else if (data.features) {
-      const values = data.features.map(({
-        properties
-      }) => properties[name]);
+      const values = data.features.map(({ properties }) => properties[name]);
       return domainFromValues(values, scaleType);
     } else if (Array.isArray(data) && data[0][name] !== void 0) {
       const values = data.map((properties) => properties[name]);
@@ -13763,10 +14120,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         if (object) {
           return accessor(object.properties || object.__source.object.properties);
         }
-        const {
-          data: data2,
-          index
-        } = info;
+        const { data: data2, index } = info;
         const proxy = createBinaryProxy(data2, index);
         return accessor(proxy);
       };
@@ -13791,20 +14145,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
     throw new Error(`Could not find property for any accessor key: ${keys}`);
   }
-  function getColorValueAccessor({
-    name
-  }, colorAggregation, data) {
+  function getColorValueAccessor({ name }, colorAggregation, data) {
     const aggregator = AGGREGATION_FUNC[colorAggregation];
     const accessor = (values) => aggregator(values, (p) => p[name]);
     return normalizeAccessor(accessor, data);
   }
-  function getColorAccessor({
-    name,
-    colorColumn
-  }, scaleType, {
-    aggregation,
-    range: range2
-  }, opacity, data) {
+  function getColorAccessor({ name, colorColumn }, scaleType, { aggregation, range: range2 }, opacity, data) {
     const scale = calculateLayerScale(colorColumn || name, scaleType, range2, data);
     const alpha = opacityToAlpha(opacity);
     let accessorKeys = getAccessorKeys(name, aggregation);
@@ -13813,11 +14159,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         accessorKeys = findAccessorKey(accessorKeys, properties);
       }
       const propertyValue = properties[accessorKeys[0]];
-      const {
-        r,
-        g,
-        b
-      } = rgb(scale(propertyValue));
+      const { r, g, b } = rgb(scale(propertyValue));
       return [r, g, b, propertyValue === null ? 0 : alpha];
     };
     return normalizeAccessor(accessor, data);
@@ -13827,10 +14169,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     let domain = [];
     let scaleColor = [];
     if (scaleType !== "identity") {
-      const {
-        colorMap,
-        colors
-      } = range2;
+      const { colorMap, colors } = range2;
       if (Array.isArray(colorMap)) {
         colorMap.forEach(([value, color2]) => {
           domain.push(value);
@@ -13850,11 +14189,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     return scale;
   }
   var FALLBACK_ICON = "data:image/svg+xml;charset=utf-8;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgcj0iNTAiLz4NCjwvc3ZnPg==";
-  function getIconUrlAccessor(field, range2, {
-    fallbackUrl,
-    maxIconSize,
-    useMaskedIcons
-  }, data) {
+  function getIconUrlAccessor(field, range2, { fallbackUrl, maxIconSize, useMaskedIcons }, data) {
     const urlToUnpackedIcon = (url) => ({
       id: `${url}@@${maxIconSize}`,
       url,
@@ -13871,10 +14206,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       return () => unknownIcon;
     }
     const mapping = {};
-    for (const {
-      value,
-      markerUrl
-    } of range2.markerMap) {
+    for (const { value, markerUrl } of range2.markerMap) {
       if (markerUrl) {
         mapping[value] = urlToUnpackedIcon(markerUrl);
       }
@@ -13886,23 +14218,15 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     return normalizeAccessor(accessor, data);
   }
   function getMaxMarkerSize(visConfig, visualChannels) {
-    const {
-      radiusRange,
-      radius
-    } = visConfig;
-    const {
-      radiusField,
-      sizeField
-    } = visualChannels;
+    const { radiusRange, radius } = visConfig;
+    const { radiusField, sizeField } = visualChannels;
     const field = radiusField || sizeField;
     return Math.ceil(radiusRange && field ? radiusRange[1] : radius);
   }
   function negateAccessor(accessor) {
     return typeof accessor === "function" ? (d, i) => -accessor(d, i) : -accessor;
   }
-  function getSizeAccessor({
-    name
-  }, scaleType, aggregation, range2, data) {
+  function getSizeAccessor({ name }, scaleType, aggregation, range2, data) {
     const scale = scaleType ? SCALE_FUNCS[scaleType]() : identity3;
     if (scaleType) {
       if (aggregation !== "count") {
@@ -13927,10 +14251,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     timestamp: (s) => import_moment_timezone.default.utc(s).format("X"),
     default: String
   };
-  function getTextAccessor({
-    name,
-    type
-  }, data) {
+  function getTextAccessor({ name, type }, data) {
     const format2 = FORMATS[type] || FORMATS.default;
     const accessor = (properties) => {
       return format2(properties[name]);
@@ -13939,24 +14260,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/api/parse-map.ts
-  var import_extensions2 = __toESM(require_extensions());
+  var import_extensions2 = __toESM(require_extensions(), 1);
   var collisionFilterExtension = new import_extensions2.CollisionFilterExtension();
   function parseMap(json) {
-    const {
-      keplerMapConfig,
-      datasets,
-      token
-    } = json;
+    const { keplerMapConfig, datasets, token } = json;
     assert(keplerMapConfig.version === "v1", "Only support Kepler v1");
-    const {
-      mapState,
-      mapStyle
-    } = keplerMapConfig.config;
-    const {
-      layers,
-      layerBlending,
-      interactionConfig
-    } = keplerMapConfig.config.visState;
+    const { mapState, mapStyle } = keplerMapConfig.config;
+    const { layers, layerBlending, interactionConfig } = keplerMapConfig.config.visState;
     return {
       id: json.id,
       title: json.title,
@@ -13966,29 +14276,16 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       initialViewState: mapState,
       mapStyle,
       token,
-      layers: layers.reverse().map(({
-        id: id4,
-        type,
-        config,
-        visualChannels
-      }) => {
+      layers: layers.reverse().map(({ id: id4, type, config, visualChannels }) => {
         try {
-          const {
-            dataId
-          } = config;
+          const { dataId } = config;
           const dataset = datasets.find((d) => d.id === dataId);
           assert(dataset, `No dataset matching dataId: ${dataId}`);
-          const {
-            data
-          } = dataset;
+          const { data } = dataset;
           assert(data, `No data loaded for dataId: ${dataId}`);
-          const {
-            Layer,
-            propMap,
-            defaultProps: defaultProps10
-          } = getLayer(type, config, dataset);
+          const { Layer: Layer6, propMap, defaultProps: defaultProps10 } = getLayer(type, config, dataset);
           const styleProps = createStyleProps(config, propMap);
-          return new Layer({
+          return new Layer6({
             id: id4,
             data,
             ...defaultProps10,
@@ -14007,15 +14304,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
   function createParametersProp(layerBlending, parameters) {
     if (layerBlending === "additive") {
-      parameters.blendFunc = [770, 772];
-      parameters.blendEquation = 32774;
+      parameters.blendFunc = [GLEnum.SRC_ALPHA, GLEnum.DST_ALPHA];
+      parameters.blendEquation = GLEnum.FUNC_ADD;
     } else if (layerBlending === "subtractive") {
-      parameters.blendFunc = [1, 775, 770, 772];
-      parameters.blendEquation = [32778, 32774];
+      parameters.blendFunc = [GLEnum.ONE, GLEnum.ONE_MINUS_DST_COLOR, GLEnum.SRC_ALPHA, GLEnum.DST_ALPHA];
+      parameters.blendEquation = [GLEnum.FUNC_SUBTRACT, GLEnum.FUNC_ADD];
     }
-    return Object.keys(parameters).length ? {
-      parameters
-    } : {};
+    return Object.keys(parameters).length ? { parameters } : {};
   }
   function createInteractionProps(interactionConfig) {
     const pickable = interactionConfig && interactionConfig.tooltip.enabled;
@@ -14070,25 +14365,17 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       strokeColorField,
       strokeColorScale
     } = visualChannels;
-    let {
-      heightField,
-      heightScale
-    } = visualChannels;
+    let { heightField, heightScale } = visualChannels;
     if (type === "hexagonId") {
       heightField = sizeField;
       heightScale = sizeScale;
     }
-    const {
-      textLabel,
-      visConfig
-    } = config;
+    const { textLabel, visConfig } = config;
     const result = {};
     if (type === "grid" || type === "hexagon") {
       result.colorScaleType = colorScale;
       if (colorField) {
-        const {
-          colorAggregation
-        } = config.visConfig;
+        const { colorAggregation } = config.visConfig;
         if (!AGGREGATION[colorAggregation]) {
           result.getColorValue = getColorValueAccessor(colorField, colorAggregation, data);
         } else {
@@ -14096,27 +14383,21 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         }
       }
     } else if (colorField) {
-      const {
-        colorAggregation: aggregation,
-        colorRange: range2
-      } = visConfig;
-      result.getFillColor = getColorAccessor(colorField, colorScale, {
-        aggregation,
-        range: range2
-      }, visConfig.opacity, data);
+      const { colorAggregation: aggregation, colorRange: range2 } = visConfig;
+      result.getFillColor = getColorAccessor(
+        colorField,
+        colorScale,
+        { aggregation, range: range2 },
+        visConfig.opacity,
+        data
+      );
     }
     if (type === "point") {
       const altitude = config.columns?.altitude;
       if (altitude) {
         result.dataTransform = (data2) => {
-          data2.features.forEach(({
-            geometry,
-            properties
-          }) => {
-            const {
-              type: type2,
-              coordinates
-            } = geometry;
+          data2.features.forEach(({ geometry, properties }) => {
+            const { type: type2, coordinates } = geometry;
             if (type2 === "Point") {
               coordinates[2] = properties[altitude];
             }
@@ -14126,40 +14407,46 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       }
     }
     if (radiusField || sizeField) {
-      result.getPointRadius = getSizeAccessor(radiusField || sizeField, radiusScale || sizeScale, visConfig.sizeAggregation, visConfig.radiusRange || visConfig.sizeRange, data);
+      result.getPointRadius = getSizeAccessor(
+        radiusField || sizeField,
+        radiusScale || sizeScale,
+        visConfig.sizeAggregation,
+        visConfig.radiusRange || visConfig.sizeRange,
+        data
+      );
     }
     if (strokeColorField) {
       const fallbackOpacity = type === "point" ? visConfig.opacity : 1;
       const opacity = visConfig.strokeOpacity !== void 0 ? visConfig.strokeOpacity : fallbackOpacity;
-      const {
-        strokeColorAggregation: aggregation,
-        strokeColorRange: range2
-      } = visConfig;
-      result.getLineColor = getColorAccessor(strokeColorField, strokeColorScale, {
-        aggregation,
-        range: range2
-      }, opacity, data);
+      const { strokeColorAggregation: aggregation, strokeColorRange: range2 } = visConfig;
+      result.getLineColor = getColorAccessor(
+        strokeColorField,
+        strokeColorScale,
+        { aggregation, range: range2 },
+        opacity,
+        data
+      );
     }
     if (heightField && visConfig.enable3d) {
-      result.getElevation = getSizeAccessor(heightField, heightScale, visConfig.heightAggregation, visConfig.heightRange || visConfig.sizeRange, data);
+      result.getElevation = getSizeAccessor(
+        heightField,
+        heightScale,
+        visConfig.heightAggregation,
+        visConfig.heightRange || visConfig.sizeRange,
+        data
+      );
     }
     if (visConfig.customMarkers) {
       const maxIconSize = getMaxMarkerSize(visConfig, visualChannels);
-      const {
-        getPointRadius,
-        getFillColor
-      } = result;
-      const {
-        customMarkersUrl,
-        customMarkersRange,
-        filled: useMaskedIcons
-      } = visConfig;
+      const { getPointRadius, getFillColor } = result;
+      const { customMarkersUrl, customMarkersRange, filled: useMaskedIcons } = visConfig;
       result.pointType = "icon";
-      result.getIcon = getIconUrlAccessor(visualChannels.customMarkersField, customMarkersRange, {
-        fallbackUrl: customMarkersUrl,
-        maxIconSize,
-        useMaskedIcons
-      }, data);
+      result.getIcon = getIconUrlAccessor(
+        visualChannels.customMarkersField,
+        customMarkersRange,
+        { fallbackUrl: customMarkersUrl, maxIconSize, useMaskedIcons },
+        data
+      );
       result._subLayerProps = {
         "points-icon": {
           loadOptions: {
@@ -14181,7 +14468,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         result.getIconSize = getPointRadius;
       }
       if (visualChannels.rotationField) {
-        result.getIconAngle = negateAccessor(getSizeAccessor(visualChannels.rotationField, void 0, null, void 0, data));
+        result.getIconAngle = negateAccessor(
+          getSizeAccessor(visualChannels.rotationField, void 0, null, void 0, data)
+        );
       }
     } else if (type === "point" || type === "tileset") {
       result.pointType = "circle";
@@ -14207,9 +14496,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       result.pointType = `${result.pointType}+text`;
       result.textCharacterSet = "auto";
       result.textFontFamily = "Inter, sans";
-      result.textFontSettings = {
-        sdf: true
-      };
+      result.textFontSettings = { sdf: true };
       result.textFontWeight = 600;
       result.textOutlineWidth = 3;
       result._subLayerProps = {
@@ -14219,11 +14506,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           extensions: [collisionFilterExtension],
           collisionEnabled: true,
           collisionGroup,
-          ...result.getPointRadius ? {
-            getRadius: result.getPointRadius
-          } : {
-            radiusScale: visConfig.radius
-          },
+          ...result.getPointRadius ? { getRadius: result.getPointRadius } : { radiusScale: visConfig.radius },
           ...secondaryField && {
             getSecondaryText,
             getSecondaryColor,
@@ -14237,13 +14520,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
   function createLoadOptions(accessToken) {
     return {
-      loadOptions: {
-        fetch: {
-          headers: {
-            Authorization: `Bearer ${accessToken}`
-          }
-        }
-      }
+      loadOptions: { fetch: { headers: { Authorization: `Bearer ${accessToken}` } } }
     };
   }
 
@@ -14271,69 +14548,34 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       headers
     };
     if (type === "tileset") {
-      dataset.data = await vectorTilesetSource({
-        ...globalOptions,
-        tableName: source
-      });
+      dataset.data = await vectorTilesetSource({ ...globalOptions, tableName: source });
     } else {
       const [spatialDataType, spatialDataColumn] = geoColumn ? geoColumn.split(":") : ["geom"];
       if (spatialDataType === "geom") {
-        const options = {
-          ...globalOptions,
-          spatialDataColumn
-        };
+        const options = { ...globalOptions, spatialDataColumn };
         if (type === "table") {
-          dataset.data = await vectorTableSource({
-            ...options,
-            columns,
-            tableName: source
-          });
+          dataset.data = await vectorTableSource({ ...options, columns, tableName: source });
         } else if (type === "query") {
           dataset.data = await vectorQuerySource({
             ...options,
+            columns,
             sqlQuery: source,
             queryParameters
           });
         }
       } else if (spatialDataType === "h3") {
-        const options = {
-          ...globalOptions,
-          aggregationExp,
-          aggregationResLevel,
-          spatialDataColumn
-        };
+        const options = { ...globalOptions, aggregationExp, aggregationResLevel, spatialDataColumn };
         if (type === "table") {
-          dataset.data = await h3TableSource({
-            ...options,
-            columns,
-            tableName: source
-          });
+          dataset.data = await h3TableSource({ ...options, tableName: source });
         } else if (type === "query") {
-          dataset.data = await h3QuerySource({
-            ...options,
-            sqlQuery: source,
-            queryParameters
-          });
+          dataset.data = await h3QuerySource({ ...options, sqlQuery: source, queryParameters });
         }
       } else if (spatialDataType === "quadbin") {
-        const options = {
-          ...globalOptions,
-          aggregationExp,
-          aggregationResLevel,
-          spatialDataColumn
-        };
+        const options = { ...globalOptions, aggregationExp, aggregationResLevel, spatialDataColumn };
         if (type === "table") {
-          dataset.data = await quadbinTableSource({
-            ...options,
-            columns,
-            tableName: source
-          });
+          dataset.data = await quadbinTableSource({ ...options, tableName: source });
         } else if (type === "query") {
-          dataset.data = await quadbinQuerySource({
-            ...options,
-            sqlQuery: source,
-            queryParameters
-          });
+          dataset.data = await quadbinQuerySource({ ...options, sqlQuery: source, queryParameters });
         }
       }
     }
@@ -14345,14 +14587,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     return cacheChanged;
   }
   async function _fetchTilestats(attribute, dataset, accessToken, apiBaseUrl) {
-    const {
-      connectionName,
-      data,
-      id: id4,
-      source,
-      type,
-      queryParameters
-    } = dataset;
+    const { connectionName, data, id: id4, source, type, queryParameters } = dataset;
     const errorContext = {
       requestType: "Tile stats",
       connection: connectionName,
@@ -14362,15 +14597,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (!("tilestats" in data)) {
       throw new CartoAPIError(new Error(`Invalid dataset for tilestats: ${id4}`), errorContext);
     }
-    const baseUrl2 = buildStatsUrl({
-      attribute,
-      apiBaseUrl,
-      ...dataset
-    });
-    const headers = {
-      Authorization: `Bearer ${accessToken}`
-    };
+    const baseUrl2 = buildStatsUrl({ attribute, apiBaseUrl, ...dataset });
+    const client = new URLSearchParams(data.tiles[0]).get("client");
+    const headers = { Authorization: `Bearer ${accessToken}` };
     const parameters = {};
+    if (client) {
+      parameters.client = client;
+    }
     if (type === "query") {
       parameters.q = source;
       if (queryParameters) {
@@ -14383,56 +14616,42 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       parameters,
       errorContext
     });
-    const {
-      attributes
-    } = data.tilestats.layers[0];
+    const { attributes } = data.tilestats.layers[0];
     const index = attributes.findIndex((d) => d.attribute === attribute);
     attributes[index] = stats;
     return true;
   }
-  async function fillInMapDatasets({
-    datasets,
-    token
-  }, clientId, apiBaseUrl, headers) {
-    const promises = datasets.map((dataset) => _fetchMapDataset(dataset, token, apiBaseUrl, clientId, headers));
+  async function fillInMapDatasets({ datasets, token }, clientId, apiBaseUrl, headers) {
+    const promises = datasets.map(
+      (dataset) => _fetchMapDataset(dataset, token, apiBaseUrl, clientId, headers)
+    );
     return await Promise.all(promises);
   }
-  async function fillInTileStats({
-    datasets,
-    keplerMapConfig,
-    token
-  }, apiBaseUrl) {
+  async function fillInTileStats({ datasets, keplerMapConfig, token }, apiBaseUrl) {
     const attributes = [];
-    const {
-      layers
-    } = keplerMapConfig.config.visState;
+    const { layers } = keplerMapConfig.config.visState;
     for (const layer of layers) {
       for (const channel of Object.keys(layer.visualChannels)) {
         const attribute = layer.visualChannels[channel]?.name;
         if (attribute) {
           const dataset = datasets.find((d) => d.id === layer.config.dataId);
           if (dataset && dataset.type !== "tileset" && dataset.data.tilestats) {
-            attributes.push({
-              attribute,
-              dataset
-            });
+            attributes.push({ attribute, dataset });
           }
         }
       }
     }
     const filteredAttributes = [];
     for (const a of attributes) {
-      if (!filteredAttributes.find(({
-        attribute,
-        dataset
-      }) => attribute === a.attribute && dataset === a.dataset)) {
+      if (!filteredAttributes.find(
+        ({ attribute, dataset }) => attribute === a.attribute && dataset === a.dataset
+      )) {
         filteredAttributes.push(a);
       }
     }
-    const promises = filteredAttributes.map(({
-      attribute,
-      dataset
-    }) => _fetchTilestats(attribute, dataset, token, apiBaseUrl));
+    const promises = filteredAttributes.map(
+      ({ attribute, dataset }) => _fetchTilestats(attribute, dataset, token, apiBaseUrl)
+    );
     return await Promise.all(promises);
   }
   async function fetchMap({
@@ -14448,21 +14667,14 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (autoRefresh || onNewData) {
       assert(onNewData, "Must define `onNewData` when using autoRefresh");
       assert(typeof onNewData === "function", "`onNewData` must be a function");
-      assert(typeof autoRefresh === "number" && autoRefresh > 0, "`autoRefresh` must be a positive number");
-    }
-    const baseUrl2 = buildPublicMapUrl({
-      apiBaseUrl,
-      cartoMapId
-    });
-    const errorContext = {
-      requestType: "Public map",
-      mapId: cartoMapId
-    };
-    const map2 = await requestWithParameters({
-      baseUrl: baseUrl2,
-      headers,
-      errorContext
-    });
+      assert(
+        typeof autoRefresh === "number" && autoRefresh > 0,
+        "`autoRefresh` must be a positive number"
+      );
+    }
+    const baseUrl2 = buildPublicMapUrl({ apiBaseUrl, cartoMapId });
+    const errorContext = { requestType: "Public map", mapId: cartoMapId };
+    const map2 = await requestWithParameters({ baseUrl: baseUrl2, headers, errorContext });
     let stopAutoRefresh;
     if (autoRefresh) {
       const intervalId = setInterval(async () => {
@@ -14478,19 +14690,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         clearInterval(intervalId);
       };
     }
-    const geojsonLayers = map2.keplerMapConfig.config.visState.layers.filter(({
-      type
-    }) => type === "geojson" || type === "point");
-    const geojsonDatasetIds = geojsonLayers.map(({
-      config
-    }) => config.dataId);
+    const geojsonLayers = map2.keplerMapConfig.config.visState.layers.filter(
+      ({ type }) => type === "geojson" || type === "point"
+    );
+    const geojsonDatasetIds = geojsonLayers.map(({ config }) => config.dataId);
     map2.datasets.forEach((dataset) => {
       if (geojsonDatasetIds.includes(dataset.id)) {
-        const {
-          config
-        } = geojsonLayers.find(({
-          config: config2
-        }) => config2.dataId === dataset.id);
+        const { config } = geojsonLayers.find(({ config: config2 }) => config2.dataId === dataset.id);
         dataset.format = "geojson";
         if (!dataset.geoColumn && config.columns.geojson) {
           dataset.geoColumn = config.columns.geojson;
@@ -14499,18 +14705,16 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     });
     await fillInMapDatasets(map2, clientId, apiBaseUrl, headers);
     await fillInTileStats(map2, apiBaseUrl);
-    const out = {
-      ...parseMap(map2),
-      ...{
-        stopAutoRefresh
-      }
-    };
+    const out = { ...parseMap(map2), ...{ stopAutoRefresh } };
     const textLayers = out.layers.filter((layer) => {
       const pointType = layer.props.pointType || "";
       return pointType.includes("text");
     });
     if (textLayers.length && window.FontFace && !document.fonts.check("12px Inter")) {
-      const font = new FontFace("Inter", "url(https://fonts.gstatic.com/s/inter/v12/UcC73FwrK3iLTeHuS_fvQtMwCp50KnMa1ZL7W0Q5nw.woff2)");
+      const font = new FontFace(
+        "Inter",
+        "url(https://fonts.gstatic.com/s/inter/v12/UcC73FwrK3iLTeHuS_fvQtMwCp50KnMa1ZL7W0Q5nw.woff2)"
+      );
       await font.load().then((f) => document.fonts.add(f));
     }
     return out;
@@ -14524,20 +14728,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       sqlQuery,
       queryParameters
     } = options;
-    const urlParameters = {
-      q: sqlQuery
-    };
+    const urlParameters = { q: sqlQuery };
     if (queryParameters) {
       urlParameters.queryParameters = JSON.stringify(queryParameters);
     }
-    const baseUrl2 = buildQueryUrl({
-      apiBaseUrl,
-      connectionName
-    });
-    const headers = {
-      Authorization: `Bearer ${options.accessToken}`,
-      ...options.headers
-    };
+    const baseUrl2 = buildQueryUrl({ apiBaseUrl, connectionName });
+    const headers = { Authorization: `Bearer ${options.accessToken}`, ...options.headers };
     const errorContext = {
       requestType: "SQL",
       connection: options.connectionName,
@@ -14577,8 +14773,8 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // ../layers/bundle/peer-dependency.ts
   var peer_dependency_exports = {};
-  var import_layers5 = __toESM(require_layers());
-  __reExport(peer_dependency_exports, __toESM(require_layers()));
+  var import_layers5 = __toESM(require_layers(), 1);
+  __reExport(peer_dependency_exports, __toESM(require_layers(), 1));
   if (!import_layers5.GeoJsonLayer) {
     throw new Error("@deck.gl/layers is not found");
   }