@deck.gl/carto 9.0.11 → 9.0.12

package/dist/cartoRasterTile-worker.js

@@ -1008,7 +1008,7 @@
   }
 
   // src/layers/schema/carto-raster-tile-loader.ts
-  var VERSION = true ? "9.0.11" : "latest";
+  var VERSION = true ? "9.0.12" : "latest";
   var id = "cartoRasterTile";
   var DEFAULT_OPTIONS = {
     cartoRasterTile: {

package/dist/cartoSpatialTile-worker.js

@@ -1397,7 +1397,7 @@
   }
 
   // src/layers/schema/carto-spatial-tile-loader.ts
-  var VERSION = true ? "9.0.11" : "latest";
+  var VERSION = true ? "9.0.12" : "latest";
   var id = "cartoSpatialTile";
   var DEFAULT_OPTIONS = {
     cartoSpatialTile: {

package/dist/cartoVectorTile-worker.js

@@ -1625,7 +1625,7 @@
   }
 
   // src/layers/schema/carto-vector-tile-loader.ts
-  var VERSION = true ? "9.0.11" : "latest";
+  var VERSION = true ? "9.0.12" : "latest";
   var id = "cartoVectorTile";
   var DEFAULT_OPTIONS = {
     cartoVectorTile: {

package/dist/dist.dev.js

@@ -9200,6 +9200,7 @@ var __exports__ = (() => {
     CARTO_SOURCES: () => CARTO_SOURCES,
     CartoAPIError: () => CartoAPIError,
     H3TileLayer: () => H3TileLayer,
+    QuadbinHeatmapTileLayer: () => quadbin_heatmap_tile_layer_default,
     QuadbinTileLayer: () => QuadbinTileLayer,
     RasterTileLayer: () => RasterTileLayer,
     SOURCE_DEFAULTS: () => SOURCE_DEFAULTS,
@@ -10304,12 +10305,367 @@ var __exports__ = (() => {
   QuadbinTileLayer.layerName = "QuadbinTileLayer";
   QuadbinTileLayer.defaultProps = defaultProps5;
 
-  // src/layers/raster-tile-layer.ts
+  // src/layers/quadbin-heatmap-tile-layer.ts
   var import_core9 = __toESM(require_core(), 1);
+  var import_layers2 = __toESM(require_layers(), 1);
 
-  // src/layers/raster-layer.ts
+  // ../../node_modules/@luma.gl/shadertools/dist/modules/math/random/random.js
+  var fs = `float random(vec3 scale, float seed) {
+return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
+}
+`;
+  var random = {
+    name: "random",
+    fs
+  };
+
+  // src/layers/heatmap.ts
+  var glsl = (s) => `${s}`;
+  var fs2 = glsl`\
+uniform heatmapUniforms {
+  float radiusPixels;
+  vec2 colorDomain;
+  vec3 color1;
+  vec3 color2;
+  vec3 color3;
+  vec3 color4;
+  vec3 color5;
+  vec3 color6;
+  float opacity;
+} heatmap;
+
+// Controls quality of heatmap, larger values increase quality at expense of performance
+const float SUPPORT = 8.0;
+const vec4 STOPS = vec4(0.2, 0.4, 0.6, 0.8);
+
+vec3 colorGradient(float value) {
+  vec3 c1;
+  vec3 c2;
+  vec2 range;
+  if (value < STOPS.x) {
+    range = vec2(0.0, STOPS.x);
+    c1 = heatmap.color1; c2 = heatmap.color2;
+  } else if (value < STOPS.y) {
+    range = STOPS.xy;
+    c1 = heatmap.color2; c2 = heatmap.color3;
+  } else if (value < STOPS.z) {
+    range = STOPS.yz;
+    c1 = heatmap.color3; c2 = heatmap.color4;
+  } else if (value < STOPS.w) {
+    range = STOPS.zw;
+    c1 = heatmap.color4; c2 = heatmap.color5;
+  } else if (value < 1.0 ) {
+    range = vec2(STOPS.w, 1.0);
+    c1 = heatmap.color5; c2 = heatmap.color6;
+  } else {
+    // Fade out to white
+    range = vec2(1.0, 10.0);
+    c1 = heatmap.color6; c2 = vec3(255.0);
+  }
+
+  float f = (value - range.x) / (range.y - range.x);
+  return mix(c1, c2, f) / 255.0;
+}
+
+const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
+float unpack(vec3 color) {
+  return 255.0 * dot(color, SHIFT);
+}
+
+vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  float accumulator = 0.0;
+
+  // Randomize the lookup values to hide the fixed number of samples
+  float offset = 0.5 * random(vec3(12.9898, 78.233, 151.7182), 0.0);
+
+  // Gaussian normalization parameters
+  const float sigma = SUPPORT / 3.0;
+  const float a = -0.5 / (sigma * sigma);
+  const float w0 = 1.0 / (2.0 * 3.141592653589793 * sigma * sigma); // 2D normalization
+
+  for (float t = -SUPPORT; t <= SUPPORT; t++) {
+  for (float s = -SUPPORT; s <= SUPPORT; s++) {
+    vec2 percent = (vec2(s, t) + offset - 0.5) / SUPPORT;
+    vec2 delta = percent * heatmap.radiusPixels / texSize;
+    vec4 offsetColor = texture(source, texCoord + delta);
+
+    // Unpack float
+    float value = unpack(offsetColor.rgb);
+
+    // Gaussian
+    float weight = w0 * exp(a * (s * s + t * t));
+    
+    accumulator += value * weight;
+  }
+  }
+
+  // Apply domain
+  float f = (accumulator - heatmap.colorDomain[0]) / (heatmap.colorDomain[1] - heatmap.colorDomain[0]);
+
+  // Color map
+  vec4 color = vec4(0.0);
+  color.rgb = colorGradient(f);
+
+  color.a = smoothstep(0.0, 0.1, f);
+  color.a = pow(color.a, 1.0 / 2.2);
+  color.a *= heatmap.opacity;
+
+  return color;
+}
+`;
+  var defaultColorRange = [
+    [255, 255, 178],
+    [254, 217, 118],
+    [254, 178, 76],
+    [253, 141, 60],
+    [240, 59, 32],
+    [189, 0, 38]
+  ];
+  var heatmap = {
+    name: "heatmap",
+    uniformPropTypes: {
+      radiusPixels: { value: 20, min: 0, softMax: 100 },
+      colorDomain: { value: [0, 1] },
+      color1: { value: [0, 0, 0] },
+      color2: { value: [0, 0, 0] },
+      color3: { value: [0, 0, 0] },
+      color4: { value: [0, 0, 0] },
+      color5: { value: [0, 0, 0] },
+      color6: { value: [0, 0, 0] },
+      opacity: { value: 1, min: 0, max: 1 }
+    },
+    uniformTypes: {
+      radiusPixels: "f32",
+      colorDomain: "vec2<f32>",
+      color1: "vec3<f32>",
+      color2: "vec3<f32>",
+      color3: "vec3<f32>",
+      color4: "vec3<f32>",
+      color5: "vec3<f32>",
+      color6: "vec3<f32>",
+      opacity: "f32"
+    },
+    getUniforms: (opts) => {
+      const {
+        colorRange = defaultColorRange,
+        radiusPixels = 20,
+        colorDomain = [0, 1],
+        opacity = 1
+      } = opts;
+      const [color1, color2, color3, color4, color5, color6] = colorRange;
+      return {
+        color1,
+        color2,
+        color3,
+        color4,
+        color5,
+        color6,
+        radiusPixels,
+        colorDomain,
+        opacity
+      };
+    },
+    dependencies: [random],
+    fs: fs2,
+    passes: [{ sampler: true }]
+  };
+
+  // src/layers/post-process-utils.ts
   var import_core8 = __toESM(require_core(), 1);
-  var import_layers2 = __toESM(require_layers(), 1);
+  var TEXTURE_PROPS = {
+    format: "rgba8unorm",
+    mipmaps: false,
+    sampler: {
+      minFilter: "linear",
+      magFilter: "linear",
+      addressModeU: "clamp-to-edge",
+      addressModeV: "clamp-to-edge"
+    }
+  };
+  function getPostProcessLayer(layer) {
+    while (layer.parent && !layer.applyPostProcess) {
+      layer = layer.parent;
+    }
+    return layer;
+  }
+  var DrawCallbackLayer = class extends import_core8.Layer {
+    initializeState() {
+      this.id = `draw-callback-${getPostProcessLayer(this).props.id}`;
+    }
+    _drawLayer() {
+      getPostProcessLayer(this).applyPostProcess();
+    }
+  };
+  DrawCallbackLayer.layerName = "DrawCallbackLayer";
+  function RTTModifier(BaseLayer) {
+    var _a;
+    return _a = class extends BaseLayer {
+      draw(opts) {
+        const { moduleParameters } = opts;
+        const { picking } = moduleParameters;
+        const postProcessLayer = getPostProcessLayer(this);
+        if (!picking.isActive) {
+          postProcessLayer.enableRTT(opts);
+        }
+        super.draw(opts);
+        if (!picking.isActive) {
+          postProcessLayer.disableRTT();
+        }
+      }
+    }, _a.layerName = `RTT-${BaseLayer.layerName}`, _a;
+  }
+  function PostProcessModifier(BaseLayer, effect) {
+    var _a;
+    return _a = class extends BaseLayer {
+      initializeState(context) {
+        super.initializeState(context);
+        this._createTextures();
+        this.internalState.postProcess = new import_core8.PostProcessEffect(effect, this.props);
+        this.internalState.postProcess.setup(context);
+      }
+      updateState(params) {
+        super.updateState(params);
+        this.internalState.postProcess.setProps(this.props);
+      }
+      renderLayers() {
+        let subLayers = super.renderLayers();
+        if (!subLayers) {
+          return null;
+        }
+        subLayers = Array.isArray(subLayers) ? subLayers : [subLayers];
+        return [...subLayers, new DrawCallbackLayer()];
+      }
+      _createTextures() {
+        const { device } = this.context;
+        this.internalState.renderBuffers = [0, 1].map((i) => {
+          return device.createFramebuffer({
+            id: `layer-fbo-${i}`,
+            colorAttachments: [device.createTexture(TEXTURE_PROPS)],
+            depthStencilAttachment: "depth16unorm"
+          });
+        });
+      }
+      _resizeBuffers(opts) {
+        const { moduleParameters } = opts;
+        const { viewport } = this.context;
+        const width = moduleParameters.devicePixelRatio * viewport.width;
+        const height = moduleParameters.devicePixelRatio * viewport.height;
+        this.internalState.renderBuffers.forEach((fbo) => fbo.resize({ width, height }));
+      }
+      enableRTT(opts) {
+        this._resizeBuffers(opts);
+        this.internalState.originalRenderPass = this.context.renderPass;
+        const [framebuffer] = this.internalState.renderBuffers;
+        this.internalState.internalRenderPass = this.context.device.beginRenderPass({
+          framebuffer,
+          parameters: { viewport: [0, 0, framebuffer.width, framebuffer.height] },
+          clearColor: this.internalState.renderInProgress ? false : [0, 0, 0, 0]
+        });
+        this.internalState.renderInProgress = true;
+        this.context.renderPass = this.internalState.internalRenderPass;
+      }
+      disableRTT() {
+        this.internalState.internalRenderPass.end();
+        this.context.renderPass = this.internalState.originalRenderPass;
+      }
+      applyPostProcess() {
+        if (!this.internalState.renderInProgress) {
+          return;
+        }
+        const [inputBuffer, swapBuffer] = this.internalState.renderBuffers;
+        const { framebuffer: target } = this.context.renderPass.props;
+        this.internalState.postProcess.postRender({
+          inputBuffer,
+          swapBuffer,
+          target
+        });
+        this.internalState.renderInProgress = false;
+      }
+    }, _a.layerName = `PostProcess${BaseLayer.layerName}`, _a;
+  }
+
+  // src/layers/quadbin-heatmap-tile-layer.ts
+  var RTTSolidPolygonLayer = class extends RTTModifier(import_layers2.SolidPolygonLayer) {
+    getShaders(type) {
+      const shaders = super.getShaders(type);
+      shaders.inject = {
+        "vs:#decl": "uniform float cellResolution;",
+        "vs:DECKGL_FILTER_COLOR": `
+  const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
+  float value = 255.0 * dot(SHIFT, color.rgb);
+
+  // Keep "power" delivered to screen constant when tiles update
+  float relativeZoom = log2(project_uScale) - cellResolution + 3.5; // range 0-1
+  float relativeArea = pow(2.0, -2.0 * relativeZoom); // range 0.25-1
+  value *= relativeArea;
+
+  // Pack float into 3 channels to pass to heatmap shader
+  color = vec4(mod(vec3(value, floor(value / SHIFT.yz)), 256.0), 255.0) / 255.0;
+      `
+      };
+      return shaders;
+    }
+    draw(opts) {
+      const cell0 = this.props.data[0];
+      const cellResolution = Number(getResolution2(cell0.id));
+      for (const model of this.state.models) {
+        model.setUniforms({ cellResolution });
+      }
+      super.draw(opts);
+    }
+  };
+  RTTSolidPolygonLayer.layerName = "RTTSolidPolygonLayer";
+  var PostProcessQuadbinTileLayer = PostProcessModifier(QuadbinTileLayer, heatmap);
+  function encodeWeight(w) {
+    return [w % 256, Math.floor(w / 256), Math.floor(w / (256 * 256))];
+  }
+  var defaultProps6 = {
+    ...QuadbinTileLayer.defaultProps,
+    getWeight: { type: "accessor", value: 1 }
+  };
+  var QuadbinHeatmapTileLayer = class extends import_core9.CompositeLayer {
+    renderLayers() {
+      const { getWeight, colorDomain, colorRange, radiusPixels, _subLayerProps } = this.props;
+      const subLayerProps = {
+        ..._subLayerProps,
+        cell: {
+          ..._subLayerProps?.cell,
+          _subLayerProps: {
+            ..._subLayerProps?.cell?._subLayerProps,
+            fill: {
+              ..._subLayerProps?.cell?._subLayerProps?.fill,
+              type: RTTSolidPolygonLayer
+            }
+          }
+        }
+      };
+      const getFillColor = typeof getWeight === "function" ? (d, info) => encodeWeight(getWeight(d, info)) : encodeWeight(getWeight);
+      return new PostProcessQuadbinTileLayer(
+        this.getSubLayerProps({
+          id: "heatmap",
+          data: this.props.data,
+          getFillColor,
+          colorDomain,
+          colorRange,
+          radiusPixels,
+          _subLayerProps: subLayerProps,
+          updateTriggers: {
+            getPosition: this.props.updateTriggers.getWeight
+          }
+        })
+      );
+    }
+  };
+  QuadbinHeatmapTileLayer.layerName = "QuadbinHeatmapTileLayer";
+  QuadbinHeatmapTileLayer.defaultProps = defaultProps6;
+  var quadbin_heatmap_tile_layer_default = QuadbinHeatmapTileLayer;
+
+  // src/layers/raster-tile-layer.ts
+  var import_core11 = __toESM(require_core(), 1);
+
+  // src/layers/raster-layer.ts
+  var import_core10 = __toESM(require_core(), 1);
+  var import_layers3 = __toESM(require_layers(), 1);
 
   // src/layers/raster-layer-vertex.glsl.ts
   var raster_layer_vertex_glsl_default = `#version 300 es
@@ -10411,8 +10767,8 @@ void main(void) {
 `;
 
   // src/layers/raster-layer.ts
-  var defaultProps6 = {
-    ...import_layers2.ColumnLayer.defaultProps,
+  var defaultProps7 = {
+    ...import_layers3.ColumnLayer.defaultProps,
     extruded: false,
     diskResolution: 4,
     vertices: [
@@ -10422,7 +10778,7 @@ void main(void) {
       [-0.5, 0.5]
     ]
   };
-  var RasterColumnLayer = class extends import_layers2.ColumnLayer {
+  var RasterColumnLayer = class extends import_layers3.ColumnLayer {
     getShaders() {
       const shaders = super.getShaders();
       const data = this.props.data;
@@ -10455,7 +10811,7 @@ void main(void) {
     }
   };
   RasterColumnLayer.layerName = "RasterColumnLayer";
-  var RasterLayer = class extends import_core8.CompositeLayer {
+  var RasterLayer = class extends import_core10.CompositeLayer {
     renderLayers() {
       const {
         data,
@@ -10504,7 +10860,7 @@ void main(void) {
     }
   };
   RasterLayer.layerName = "RasterLayer";
-  RasterLayer.defaultProps = defaultProps6;
+  RasterLayer.defaultProps = defaultProps7;
 
   // src/layers/raster-tile-layer.ts
   var renderSubLayers3 = (props) => {
@@ -10513,11 +10869,11 @@ void main(void) {
       return null;
     return new RasterLayer(props, { tileIndex });
   };
-  var defaultProps7 = {
+  var defaultProps8 = {
     data: TilejsonPropType,
     tileSize: DEFAULT_TILE_SIZE
   };
-  var RasterTileLayer = class extends import_core9.CompositeLayer {
+  var RasterTileLayer = class extends import_core11.CompositeLayer {
     getLoadOptions() {
       const loadOptions = super.getLoadOptions() || {};
       const tileJSON = this.props.data;
@@ -10543,10 +10899,10 @@ void main(void) {
     }
   };
   RasterTileLayer.layerName = "RasterTileLayer";
-  RasterTileLayer.defaultProps = defaultProps7;
+  RasterTileLayer.defaultProps = defaultProps8;
 
   // src/layers/vector-tile-layer.ts
-  var import_core10 = __toESM(require_core2(), 1);
+  var import_core12 = __toESM(require_core2(), 1);
 
   // src/layers/schema/carto-properties-tile.ts
   var TileReader4 = class {
@@ -10649,7 +11005,7 @@ void main(void) {
   // src/layers/vector-tile-layer.ts
   var import_extensions = __toESM(require_extensions(), 1);
   var import_geo_layers6 = __toESM(require_geo_layers(), 1);
-  var import_layers3 = __toESM(require_layers(), 1);
+  var import_layers4 = __toESM(require_layers(), 1);
 
   // ../../node_modules/@loaders.gl/gis/dist/lib/binary-features/binary-to-geojson.js
   function binaryToGeojson(data, options) {
@@ -10814,8 +11170,8 @@ void main(void) {
   }
 
   // src/layers/vector-tile-layer.ts
-  (0, import_core10.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
-  var defaultProps8 = {
+  (0, import_core12.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
+  var defaultProps9 = {
     ...import_geo_layers6.MVTLayer.defaultProps,
     data: TilejsonPropType,
     dataComparator: TilejsonPropType.equal,
@@ -10889,7 +11245,7 @@ void main(void) {
         extensions: [new import_extensions.ClipExtension(), ...props.extensions || []],
         clipBounds: [west, south, east, north]
       };
-      const subLayer = new import_layers3.GeoJsonLayer(subLayerProps);
+      const subLayer = new import_layers4.GeoJsonLayer(subLayerProps);
       return subLayer;
     }
     getPickingInfo(params) {
@@ -10904,7 +11260,7 @@ void main(void) {
     }
   };
   VectorTileLayer.layerName = "VectorTileLayer";
-  VectorTileLayer.defaultProps = defaultProps8;
+  VectorTileLayer.defaultProps = defaultProps9;
 
   // src/basemap.ts
   var baseUrl = "https://basemaps.cartocdn.com/gl/{basemap}-gl-style/style.json";
@@ -12973,14 +13329,14 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/api/common.ts
-  var import_core11 = __toESM(require_core(), 1);
+  var import_core13 = __toESM(require_core(), 1);
   var DEFAULT_API_BASE_URL = "https://gcp-us-east1.api.carto.com";
   var DEFAULT_CLIENT = "deck-gl-carto";
   var V3_MINOR_VERSION = "3.4";
   var MAX_GET_LENGTH = 8192;
   var DEFAULT_PARAMETERS = {
     v: V3_MINOR_VERSION,
-    deckglVersion: import_core11.VERSION
+    deckglVersion: import_core13.VERSION
   };
   var DEFAULT_HEADERS = {
     Accept: "application/json",
@@ -13992,12 +14348,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   })(GLEnum || (GLEnum = {}));
 
   // src/api/parse-map.ts
-  var import_core12 = __toESM(require_core(), 1);
+  var import_core14 = __toESM(require_core(), 1);
 
   // src/api/layer-map.ts
   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_layers5 = __toESM(require_layers(), 1);
   var import_geo_layers7 = __toESM(require_geo_layers(), 1);
   var SCALE_FUNCS = {
     linear: linear2,
@@ -14070,7 +14426,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     elevationPercentile: ["elevationLowerPercentile", "elevationUpperPercentile"],
     percentile: ["lowerPercentile", "upperPercentile"]
   };
-  var defaultProps9 = {
+  var defaultProps10 = {
     lineMiterLimit: 2,
     lineWidthUnits: "pixels",
     pointRadiusUnits: "pixels",
@@ -14093,7 +14449,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     const hexagonId = config.columns?.hex_id;
     const layerTypeDefs = {
       point: {
-        Layer: import_layers4.GeoJsonLayer,
+        Layer: import_layers5.GeoJsonLayer,
         propMap: {
           columns: {
             altitude: (x) => ({ parameters: { depthTest: Boolean(x) } })
@@ -14102,7 +14458,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         }
       },
       geojson: {
-        Layer: import_layers4.GeoJsonLayer
+        Layer: import_layers5.GeoJsonLayer
       },
       grid: {
         Layer: import_aggregation_layers.CPUGridLayer,
@@ -14130,7 +14486,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     return {
       ...layer,
       propMap: mergePropMaps(basePropMap, layer.propMap),
-      defaultProps: { ...defaultProps9, ...layer.defaultProps }
+      defaultProps: { ...defaultProps10, ...layer.defaultProps }
     };
   }
   function layerFromTileDataset(scheme, type) {
@@ -14155,7 +14511,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       Layer: layerFromTileDataset(scheme),
       propMap: basePropMap,
       defaultProps: {
-        ...defaultProps9,
+        ...defaultProps10,
         ...aggregationExp && { aggregationExp },
         ...aggregationResLevel && { aggregationResLevel },
         uniqueIdProperty: "geoid"
@@ -14373,12 +14729,12 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           assert(dataset, `No dataset matching dataId: ${dataId}`);
           const { data } = dataset;
           assert(data, `No data loaded for dataId: ${dataId}`);
-          const { Layer: Layer6, propMap, defaultProps: defaultProps10 } = getLayer(type, config, dataset);
+          const { Layer: Layer8, propMap, defaultProps: defaultProps11 } = getLayer(type, config, dataset);
           const styleProps = createStyleProps(config, propMap);
-          return new Layer6({
+          return new Layer8({
             id: id4,
             data,
-            ...defaultProps10,
+            ...defaultProps11,
             ...createInteractionProps(interactionConfig),
             ...styleProps,
             ...createChannelProps(id4, type, config, visualChannels, data),
@@ -14386,7 +14742,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
             ...createLoadOptions(token)
           });
         } catch (e) {
-          import_core12.log.error(e.message)();
+          import_core14.log.error(e.message)();
           return void 0;
         }
       })
@@ -14843,6 +15199,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     H3TileLayer,
     _PointLabelLayer: PointLabelLayer,
     QuadbinTileLayer,
+    QuadbinHeatmapTileLayer: quadbin_heatmap_tile_layer_default,
     RasterTileLayer,
     VectorTileLayer
   };
@@ -14863,9 +15220,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // ../layers/bundle/peer-dependency.ts
   var peer_dependency_exports = {};
-  var import_layers5 = __toESM(require_layers(), 1);
+  var import_layers6 = __toESM(require_layers(), 1);
   __reExport(peer_dependency_exports, __toESM(require_layers(), 1));
-  if (!import_layers5.GeoJsonLayer) {
+  if (!import_layers6.GeoJsonLayer) {
     throw new Error("@deck.gl/layers is not found");
   }