ol 10.4.1-dev.1740542736318 → 10.4.1-dev.1740751716860

package/expr/gpu.d.ts

@@ -67,7 +67,6 @@ export function uniformNameForVariable(variableName: string): string;
  */
 /**
  * @typedef {Object} CompilationContext
- * @property {boolean} [inFragmentShader] If false, means the expression output should be made for a vertex shader
  * @property {Object<string, CompilationContextProperty>} properties The values for properties used in 'get' expressions.
  * @property {Object<string, CompilationContextVariable>} variables The values for variables used in 'var' expressions.
  * @property {Object<string, string>} functions Lookup of functions used by the style.
@@ -122,10 +121,6 @@ export type CompilationContextVariable = {
     type: number;
 };
 export type CompilationContext = {
-    /**
-     * If false, means the expression output should be made for a vertex shader
-     */
-    inFragmentShader?: boolean | undefined;
     /**
      * The values for properties used in 'get' expressions.
      */

package/expr/gpu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gpu.d.ts","sourceRoot":"","sources":["gpu.js"],"names":[],"mappings":"AA6BA;;;;GAIG;AACH,gCAHW,MAAM,GACL,MAAM,CAKjB;AAED;;;;GAIG;AACH,mCAHW,KAAK,CAAC,MAAM,CAAC,GACZ,MAAM,CASjB;AAED;;;;;;GAMG;AACH,mCALW,MAAM,GAAC,OAAO,aAAa,EAAE,KAAK,GAGjC,MAAM,CAMjB;AAED;;;;GAIG;AACH,iCAHW,MAAM,GAAC,OAAO,YAAY,EAAE,IAAI,GAC/B,MAAM,CAKjB;AAMD;;;;GAIG;AACH,kDAHW,MAAM,GACL,MAAM,CAOjB;AAED;;;;;;GAMG;AACH,qCAHW,MAAM,GACL,MAAM,CAIjB;AAED;;;;GAIG;AACH,qDAHW,MAAM,GACL,MAAM,CAIjB;AAED;;GAEG;AACH;;;GAGG;AACH;;;GAGG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;;;;GAUG;AAEH;;GAEG;AACH,yCAFY,kBAAkB,CAY7B;AASD;;GAEG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AACH,yCANW,OAAO,iBAAiB,EAAE,iBAAiB,QAC3C,MAAM,kBACN,OAAO,iBAAiB,EAAE,cAAc,sBACxC,kBAAkB,GACjB,kBAAkB,CAU7B;AA7BD,oCAAqC,mBAAmB,CAAC;AAEzD,uCAAwC,WAAW,CAAC;AACpD,0CAA2C,cAAc,CAAC;6BAvD7C,OAAO,iBAAiB,EAAE,cAAc;yBAIxC,OAAO,iBAAiB,EAAE,UAAU;gCAIpC,OAAO,iBAAiB,EAAE,iBAAiB;;;;;UAK1C,MAAM;;;;UACN,MAAM;;;;;;UAKN,MAAM;;;;UACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAWN,OAAO;;;;kBACP,OAAO;;iCA0BR,MAAM;;;;uBAIN,CAAS,IAAkB,EAAlB,kBAAkB,EAAE,IAAc,EAAd,cAAc,EAAE,IAAM,EAAN,MAAM,KAAG,MAAM;2BAzK9C,4BAA4B;+BAYhD,iBAAiB"}
+{"version":3,"file":"gpu.d.ts","sourceRoot":"","sources":["gpu.js"],"names":[],"mappings":"AA6BA;;;;GAIG;AACH,gCAHW,MAAM,GACL,MAAM,CAKjB;AAED;;;;GAIG;AACH,mCAHW,KAAK,CAAC,MAAM,CAAC,GACZ,MAAM,CASjB;AAED;;;;;;GAMG;AACH,mCALW,MAAM,GAAC,OAAO,aAAa,EAAE,KAAK,GAGjC,MAAM,CAMjB;AAED;;;;GAIG;AACH,iCAHW,MAAM,GAAC,OAAO,YAAY,EAAE,IAAI,GAC/B,MAAM,CAKjB;AAMD;;;;GAIG;AACH,kDAHW,MAAM,GACL,MAAM,CAOjB;AAED;;;;;;GAMG;AACH,qCAHW,MAAM,GACL,MAAM,CAIjB;AAED;;;;GAIG;AACH,qDAHW,MAAM,GACL,MAAM,CAIjB;AAED;;GAEG;AACH;;;GAGG;AACH;;;GAGG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;;;GASG;AAEH;;GAEG;AACH,yCAFY,kBAAkB,CAW7B;AASD;;GAEG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AACH,yCANW,OAAO,iBAAiB,EAAE,iBAAiB,QAC3C,MAAM,kBACN,OAAO,iBAAiB,EAAE,cAAc,sBACxC,kBAAkB,GACjB,kBAAkB,CAU7B;AA7BD,oCAAqC,mBAAmB,CAAC;AAEzD,uCAAwC,WAAW,CAAC;AACpD,0CAA2C,cAAc,CAAC;6BArD7C,OAAO,iBAAiB,EAAE,cAAc;yBAIxC,OAAO,iBAAiB,EAAE,UAAU;gCAIpC,OAAO,iBAAiB,EAAE,iBAAiB;;;;;UAK1C,MAAM;;;;UACN,MAAM;;;;;;UAKN,MAAM;;;;UACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAUN,OAAO;;;;kBACP,OAAO;;iCAyBR,MAAM;;;;uBAIN,CAAS,IAAkB,EAAlB,kBAAkB,EAAE,IAAc,EAAd,cAAc,EAAE,IAAM,EAAN,MAAM,KAAG,MAAM;2BAvK9C,4BAA4B;+BAYhD,iBAAiB"}

package/expr/gpu.js

@@ -136,7 +136,6 @@ export function uniformNameForVariable(variableName) {
 
 /**
  * @typedef {Object} CompilationContext
- * @property {boolean} [inFragmentShader] If false, means the expression output should be made for a vertex shader
  * @property {Object<string, CompilationContextProperty>} properties The values for properties used in 'get' expressions.
  * @property {Object<string, CompilationContextVariable>} variables The values for variables used in 'var' expressions.
  * @property {Object<string, string>} functions Lookup of functions used by the style.
@@ -151,7 +150,6 @@ export function uniformNameForVariable(variableName) {
  */
 export function newCompilationContext() {
   return {
-    inFragmentShader: false,
     variables: {},
     properties: {},
     functions: {},
@@ -223,18 +221,15 @@ const compilers = {
         type: expression.type,
       };
     }
-    const prefix = context.inFragmentShader ? 'v_prop_' : 'a_prop_';
-    return prefix + propName;
+    return 'a_prop_' + propName;
   },
   [Ops.Id]: (context) => {
     context.featureId = true;
-    const prefix = context.inFragmentShader ? 'v_' : 'a_';
-    return prefix + FEATURE_ID_PROPERTY_NAME;
+    return 'a_' + FEATURE_ID_PROPERTY_NAME;
   },
   [Ops.GeometryType]: (context) => {
     context.geometryType = true;
-    const prefix = context.inFragmentShader ? 'v_' : 'a_';
-    return prefix + GEOMETRY_TYPE_PROPERTY_NAME;
+    return 'a_' + GEOMETRY_TYPE_PROPERTY_NAME;
   },
   [Ops.LineMetric]: () => 'currentLineMetric', // this variable is assumed to always be present in shaders, default is 0.
   [Ops.Var]: (context, expression) => {

package/layer/BaseVector.d.ts

@@ -119,10 +119,10 @@ export type Options<FeatureType extends import("../Feature").FeatureLike, Vector
  * @template {import('../Feature').FeatureLike} FeatureType
  * @template {import("../source/Vector.js").default<FeatureType>|import("../source/VectorTile.js").default<FeatureType>} VectorSourceType<FeatureType>
  * @extends {Layer<VectorSourceType, RendererType>}
- * @template {import("../renderer/canvas/VectorLayer.js").default|import("../renderer/canvas/VectorTileLayer.js").default|import("../renderer/canvas/VectorImageLayer.js").default|import("../renderer/webgl/PointsLayer.js").default} RendererType
+ * @template {import("../renderer/canvas/VectorLayer.js").default|import("../renderer/canvas/VectorTileLayer.js").default|import("../renderer/canvas/VectorImageLayer.js").default|import("../renderer/webgl/VectorLayer.js").default|import("../renderer/webgl/PointsLayer.js").default} RendererType
  * @api
  */
-declare class BaseVectorLayer<FeatureType extends import("../Feature").FeatureLike, VectorSourceType extends import("../source/Vector.js").default<FeatureType> | import("../source/VectorTile.js").default<FeatureType>, RendererType extends import("../renderer/canvas/VectorLayer.js").default | import("../renderer/canvas/VectorTileLayer.js").default | import("../renderer/canvas/VectorImageLayer.js").default | import("../renderer/webgl/PointsLayer.js").default> extends Layer<VectorSourceType, RendererType> {
+declare class BaseVectorLayer<FeatureType extends import("../Feature").FeatureLike, VectorSourceType extends import("../source/Vector.js").default<FeatureType> | import("../source/VectorTile.js").default<FeatureType>, RendererType extends import("../renderer/canvas/VectorLayer.js").default | import("../renderer/canvas/VectorTileLayer.js").default | import("../renderer/canvas/VectorImageLayer.js").default | import("../renderer/webgl/VectorLayer.js").default | import("../renderer/webgl/PointsLayer.js").default> extends Layer<VectorSourceType, RendererType> {
     /**
      * @param {Options<FeatureType, VectorSourceType>} [options] Options.
      */

package/layer/BaseVector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseVector.d.ts","sourceRoot":"","sources":["BaseVector.js"],"names":[],"mappings":";;;;iCAea,CAAC,IACD,CAAC,SAAS,OAAO,qBAAqB,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,OAAO,eAAe,EAAE,WAAW,CAAC,GAAG,CAAC,GAAG,KAAK;oBAI7E,WAAW,SAA9C,OAAQ,YAAY,EAAE,WAAY,EAC0E,gBAAgB,SAA3H,OAAO,qBAAqB,EAAE,OAAO,CAAC,WAAW,CAAC,GAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,WAAW,CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDxH;;;;;;;;;;;;GAYG;AACH,8BANgD,WAAW,SAA9C,OAAQ,YAAY,EAAE,WAAY,EAC0E,gBAAgB,SAA3H,OAAO,qBAAqB,EAAE,OAAO,CAAC,WAAW,CAAC,GAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,WAAW,CAAE,EAE+G,YAAY,SAArO,OAAO,mCAAmC,EAAE,OAAO,GAAC,OAAO,uCAAuC,EAAE,OAAO,GAAC,OAAO,wCAAwC,EAAE,OAAO,GAAC,OAAO,kCAAkC,EAAE,OAAQ;IAIpO;;OAEG;IACH,sBAFW,OAAO,CAAC,WAAW,EAAE,gBAAgB,CAAC,EA2DhD;IA9CC;;;OAGG;IACH,mBAA2E;IAE3E;;;OAGG;IACH,sBACiE;IAEjE;;;;OAIG;IACH,eAAkB;IAElB;;;;OAIG;IACH,uBAA+B;IAI/B;;;OAGG;IACH,8BAGW;IAEX;;;OAGG;IACH,gCAGW;IA8Bb;;OAEG;IACH,mBAFY,MAAM,GAAC,SAAS,CAI3B;IAED;;OAEG;IACH,kBAFY,OAAO,cAAc,EAAE,aAAa,GAAC,IAAI,GAAC,SAAS,CAM9D;IAED;;;;;OAKG;IACH,YAHY,OAAO,mBAAmB,EAAE,SAAS,GAAC,OAAO,kBAAkB,EAAE,aAAa,GAAC,IAAI,GAAC,SAAS,CAKxG;IAED;;;;OAIG;IACH,oBAHY,OAAO,mBAAmB,EAAE,aAAa,GAAC,SAAS,CAK9D;IAED;;;OAGG;IACH,2BAHY,OAAO,CAKlB;IAED;;;OAGG;IACH,6BAHY,OAAO,CAKlB;IAgBD;;;OAGG;IACH,4BAHW,OAAO,cAAc,EAAE,aAAa,GAAC,IAAI,GAAC,SAAS,QAK7D;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,iBAHW,OAAO,mBAAmB,EAAE,SAAS,GAAC,OAAO,kBAAkB,EAAE,aAAa,GAAC,IAAI,QAS7F;IAED;;;OAGG;IACH,wBAHW,OAAO,GAAC,MAAM,GAAC,MAAM,QAM/B;CACF;kBAvRiB,YAAY"}
+{"version":3,"file":"BaseVector.d.ts","sourceRoot":"","sources":["BaseVector.js"],"names":[],"mappings":";;;;iCAea,CAAC,IACD,CAAC,SAAS,OAAO,qBAAqB,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,OAAO,eAAe,EAAE,WAAW,CAAC,GAAG,CAAC,GAAG,KAAK;oBAI7E,WAAW,SAA9C,OAAQ,YAAY,EAAE,WAAY,EAC0E,gBAAgB,SAA3H,OAAO,qBAAqB,EAAE,OAAO,CAAC,WAAW,CAAC,GAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,WAAW,CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDxH;;;;;;;;;;;;GAYG;AACH,8BANgD,WAAW,SAA9C,OAAQ,YAAY,EAAE,WAAY,EAC0E,gBAAgB,SAA3H,OAAO,qBAAqB,EAAE,OAAO,CAAC,WAAW,CAAC,GAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,WAAW,CAAE,EAEkK,YAAY,SAAxR,OAAO,mCAAmC,EAAE,OAAO,GAAC,OAAO,uCAAuC,EAAE,OAAO,GAAC,OAAO,wCAAwC,EAAE,OAAO,GAAC,OAAO,kCAAkC,EAAE,OAAO,GAAC,OAAO,kCAAkC,EAAE,OAAQ;IAIvR;;OAEG;IACH,sBAFW,OAAO,CAAC,WAAW,EAAE,gBAAgB,CAAC,EA2DhD;IA9CC;;;OAGG;IACH,mBAA2E;IAE3E;;;OAGG;IACH,sBACiE;IAEjE;;;;OAIG;IACH,eAAkB;IAElB;;;;OAIG;IACH,uBAA+B;IAI/B;;;OAGG;IACH,8BAGW;IAEX;;;OAGG;IACH,gCAGW;IA8Bb;;OAEG;IACH,mBAFY,MAAM,GAAC,SAAS,CAI3B;IAED;;OAEG;IACH,kBAFY,OAAO,cAAc,EAAE,aAAa,GAAC,IAAI,GAAC,SAAS,CAM9D;IAED;;;;;OAKG;IACH,YAHY,OAAO,mBAAmB,EAAE,SAAS,GAAC,OAAO,kBAAkB,EAAE,aAAa,GAAC,IAAI,GAAC,SAAS,CAKxG;IAED;;;;OAIG;IACH,oBAHY,OAAO,mBAAmB,EAAE,aAAa,GAAC,SAAS,CAK9D;IAED;;;OAGG;IACH,2BAHY,OAAO,CAKlB;IAED;;;OAGG;IACH,6BAHY,OAAO,CAKlB;IAgBD;;;OAGG;IACH,4BAHW,OAAO,cAAc,EAAE,aAAa,GAAC,IAAI,GAAC,SAAS,QAK7D;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,iBAHW,OAAO,mBAAmB,EAAE,SAAS,GAAC,OAAO,kBAAkB,EAAE,aAAa,GAAC,IAAI,QAS7F;IAED;;;OAGG;IACH,wBAHW,OAAO,GAAC,MAAM,GAAC,MAAM,QAM/B;CACF;kBAvRiB,YAAY"}

package/layer/BaseVector.js

@@ -86,7 +86,7 @@ const Property = {
  * @template {import('../Feature').FeatureLike} FeatureType
  * @template {import("../source/Vector.js").default<FeatureType>|import("../source/VectorTile.js").default<FeatureType>} VectorSourceType<FeatureType>
  * @extends {Layer<VectorSourceType, RendererType>}
- * @template {import("../renderer/canvas/VectorLayer.js").default|import("../renderer/canvas/VectorTileLayer.js").default|import("../renderer/canvas/VectorImageLayer.js").default|import("../renderer/webgl/PointsLayer.js").default} RendererType
+ * @template {import("../renderer/canvas/VectorLayer.js").default|import("../renderer/canvas/VectorTileLayer.js").default|import("../renderer/canvas/VectorImageLayer.js").default|import("../renderer/webgl/VectorLayer.js").default|import("../renderer/webgl/PointsLayer.js").default} RendererType
  * @api
  */
 class BaseVectorLayer extends Layer {

package/layer/Flow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Flow.d.ts","sourceRoot":"","sources":["Flow.js"],"names":[],"mappings":";;;;;sBAuRc,MAAM;;;;wBACN,MAAM;;;;yBACN,MAAM;;;;2BACN,MAAM;;;;kCACN,MAAM;;;;oCACN,MAAM;;;;+BACN,MAAM;;;;iCACN,MAAM;;yBA9QP,OAAO,uBAAuB,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;cAetC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8WpB;;;;;;;GAOG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EA2CjB;IAlCC;;;OAGG;IACH,eAAiC;IAKjC;;;OAGG;IACH,kBAAiC;IAEjC;;;OAGG;IACH,qBAAuC;IAEvC;;;OAGG;IACH,mBAAmC;IAEnC;;;OAGG;IACH,wBAAkD;IAKpD;;OAEG;IACH,4BAIC;IAED;;;OAGG;IACH;;aAGC;IAED;;;;;OAKG;IACH,mBAJW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,GACL,KAAK,CAAC,UAAU,CAAC,CAM5B;CAgBF;8BAvewC,gCAAgC;0BAG/C,eAAe"}
+{"version":3,"file":"Flow.d.ts","sourceRoot":"","sources":["Flow.js"],"names":[],"mappings":";;;;;sBAuRc,MAAM;;;;wBACN,MAAM;;;;yBACN,MAAM;;;;2BACN,MAAM;;;;kCACN,MAAM;;;;oCACN,MAAM;;;;+BACN,MAAM;;;;iCACN,MAAM;;yBA9QP,OAAO,uBAAuB,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;cAetC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6WpB;;;;;;;GAOG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EA2CjB;IAlCC;;;OAGG;IACH,eAAiC;IAKjC;;;OAGG;IACH,kBAAiC;IAEjC;;;OAGG;IACH,qBAAuC;IAEvC;;;OAGG;IACH,mBAAmC;IAEnC;;;OAGG;IACH,wBAAkD;IAKpD;;OAEG;IACH,4BAIC;IAED;;;OAGG;IACH;;aAGC;IAED;;;;;OAKG;IACH,mBAJW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,GACL,KAAK,CAAC,UAAU,CAAC,CAM5B;CAgBF;8BArewC,gCAAgC;0BAE/C,eAAe"}

package/layer/Flow.js

@@ -7,9 +7,9 @@ import {
   newCompilationContext,
   uniformNameForVariable,
 } from '../expr/gpu.js';
+import {expressionToGlsl} from '../render/webgl/compileUtil.js';
 import FlowLayerRenderer, {A, U, V} from '../renderer/webgl/FlowLayer.js';
 import {Attributes as BA, Uniforms as BU} from '../renderer/webgl/TileLayer.js';
-import {expressionToGlsl} from '../webgl/styleparser.js';
 import BaseTileLayer from './BaseTile.js';
 import LayerProperty from './Property.js';
 
@@ -293,7 +293,6 @@ const particleColorVertexShader = `
  */
 function parseStyle(style) {
   const context = newCompilationContext();
-  context.inFragmentShader = true;
   const pipeline = [];
 
   if (style.color !== undefined) {
@@ -364,7 +363,7 @@ function parseStyle(style) {
         vx * ${U.ROTATION}.y + vy * ${U.ROTATION}.x
       );
 
-      float v_prop_speed = length(velocity);
+      float a_prop_speed = length(velocity);
 
       vec4 color;
 

package/layer/Heatmap.d.ts

@@ -1,4 +1,5 @@
 export default Heatmap;
+export type WeightExpression = import("../style/flat.js").NumberExpression | string | ((arg0: import("../Feature.js").default) => number);
 export type Options<FeatureType extends import("../Feature.js").FeatureLike = import("../Feature.js").default<import("../geom.js").Geometry>, VectorSourceType extends import("../source/Vector.js").default<FeatureType> = import("../source/Vector.js").default<FeatureType>> = {
     /**
      * A CSS class name to set to the layer element.
@@ -50,19 +51,31 @@ export type Options<FeatureType extends import("../Feature.js").FeatureLike = im
      */
     gradient?: string[] | undefined;
     /**
-     * Radius size in pixels.
+     * Radius size in pixels. Note that for LineStrings,
+     * the width of the line will be double the radius.
      */
-    radius?: number | undefined;
+    radius?: import("../style/flat.js").NumberExpression | undefined;
     /**
-     * Blur size in pixels.
+     * Blur size in pixels. This is added to the `radius`
+     * parameter above to create the final size of the blur effect.
      */
-    blur?: number | undefined;
+    blur?: import("../style/flat.js").NumberExpression | undefined;
     /**
      * The feature
-     * attribute to use for the weight or a function that returns a weight from a feature. Weight values
+     * attribute to use for the weight. This also supports expressions returning a number or a function that returns a weight from a feature. Weight values
      * should range from 0 to 1 (and values outside will be clamped to that range).
      */
-    weight?: string | ((arg0: import("../Feature.js").default) => number) | undefined;
+    weight?: WeightExpression | undefined;
+    /**
+     * Optional filter expression.
+     */
+    filter?: import("../style/flat.js").BooleanExpression | undefined;
+    /**
+     * Variables used in expressions (optional)
+     */
+    variables?: {
+        [x: string]: string | number | boolean | number[];
+    } | undefined;
     /**
      * Point source.
      */
@@ -85,14 +98,20 @@ export type Options<FeatureType extends import("../Feature.js").FeatureLike = im
  * @fires import("../render/Event.js").RenderEvent#postrender
  * @template {import("../Feature.js").FeatureLike} [FeatureType=import("../Feature.js").default]
  * @template {import("../source/Vector.js").default<FeatureType>} [VectorSourceType=import("../source/Vector.js").default<FeatureType>]
- * @extends {BaseVector<FeatureType, VectorSourceType, WebGLPointsLayerRenderer>}
+ * @extends {BaseVector<FeatureType, VectorSourceType, WebGLVectorLayerRenderer>}
  * @api
  */
-declare class Heatmap<FeatureType extends import("../Feature.js").FeatureLike = import("../Feature.js").default<import("../geom.js").Geometry>, VectorSourceType extends import("../source/Vector.js").default<FeatureType> = import("../source/Vector.js").default<FeatureType>> extends BaseVector<FeatureType, VectorSourceType, WebGLPointsLayerRenderer> {
+declare class Heatmap<FeatureType extends import("../Feature.js").FeatureLike = import("../Feature.js").default<import("../geom.js").Geometry>, VectorSourceType extends import("../source/Vector.js").default<FeatureType> = import("../source/Vector.js").default<FeatureType>> extends BaseVector<FeatureType, VectorSourceType, WebGLVectorLayerRenderer> {
     /**
      * @param {Options<FeatureType, VectorSourceType>} [options] Options.
      */
     constructor(options?: Options<FeatureType, VectorSourceType>);
+    filter_: import("../style/flat.js").BooleanExpression;
+    /**
+     * @type {import('../style/flat.js').StyleVariables}
+     * @private
+     */
+    private styleVariables_;
     /**
      * @private
      * @type {HTMLCanvasElement}
@@ -101,14 +120,14 @@ declare class Heatmap<FeatureType extends import("../Feature.js").FeatureLike =
     /**
      * @private
      */
-    private weightFunction_;
+    private weight_;
     /**
      * Return the blur size in pixels.
-     * @return {number} Blur size in pixels.
+     * @return {import("../style/flat.js").NumberExpression} Blur size in pixels.
      * @api
      * @observable
      */
-    getBlur(): number;
+    getBlur(): import("../style/flat.js").NumberExpression;
     /**
      * Return the gradient colors as array of strings.
      * @return {Array<string>} Colors.
@@ -118,22 +137,22 @@ declare class Heatmap<FeatureType extends import("../Feature.js").FeatureLike =
     getGradient(): Array<string>;
     /**
      * Return the size of the radius in pixels.
-     * @return {number} Radius size in pixel.
+     * @return {import("../style/flat.js").NumberExpression} Radius size in pixel.
      * @api
      * @observable
      */
-    getRadius(): number;
+    getRadius(): import("../style/flat.js").NumberExpression;
     /**
      * @private
      */
     private handleGradientChanged_;
     /**
      * Set the blur size in pixels.
-     * @param {number} blur Blur size in pixels.
+     * @param {import("../style/flat.js").NumberExpression} blur Blur size in pixels (supports expressions).
      * @api
      * @observable
      */
-    setBlur(blur: number): void;
+    setBlur(blur: import("../style/flat.js").NumberExpression): void;
     /**
      * Set the gradient colors as array of strings.
      * @param {Array<string>} colors Gradient.
@@ -143,16 +162,33 @@ declare class Heatmap<FeatureType extends import("../Feature.js").FeatureLike =
     setGradient(colors: Array<string>): void;
     /**
      * Set the size of the radius in pixels.
-     * @param {number} radius Radius size in pixel.
+     * @param {import("../style/flat.js").NumberExpression} radius Radius size in pixel (supports expressions).
      * @api
      * @observable
      */
-    setRadius(radius: number): void;
+    setRadius(radius: import("../style/flat.js").NumberExpression): void;
+    /**
+     * Set the filter expression
+     * @param {import("../style/flat.js").BooleanExpression} filter Filter expression
+     * @api
+     */
+    setFilter(filter: import("../style/flat.js").BooleanExpression): void;
+    /**
+     * Set the weight expression
+     * @param {WeightExpression} weight Weight expression
+     * @api
+     */
+    setWeight(weight: WeightExpression): void;
+    /**
+     * Update any variables used by the layer style and trigger a re-render.
+     * @param {import('../style/flat.js').StyleVariables} variables Variables to update.
+     */
+    updateStyleVariables(variables: import("../style/flat.js").StyleVariables): void;
     /**
      * @override
      */
     override renderDeclutter(): void;
 }
-import WebGLPointsLayerRenderer from '../renderer/webgl/PointsLayer.js';
+import WebGLVectorLayerRenderer from '../renderer/webgl/VectorLayer.js';
 import BaseVector from './BaseVector.js';
 //# sourceMappingURL=Heatmap.d.ts.map

package/layer/Heatmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Heatmap.d.ts","sourceRoot":"","sources":["Heatmap.js"],"names":[],"mappings":";oBAUoD,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY,mEACiB,gBAAgB,SAAtE,OAAQ,qBAAqB,EAAE,OAAO,CAAC,WAAW,CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAuBnC,OAAO,eAAe,EAAE,OAAO,KAAE,MAAM;;;;;;;;;;;;AAuBrE;;;;;;;;;;;;;GAaG;AACH,sBALoD,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY,mEACiB,gBAAgB,SAAtE,OAAQ,qBAAqB,EAAE,OAAO,CAAC,WAAW,CAAE;IAK/D;;OAEG;IACH,sBAFW,OAAO,CAAC,WAAW,EAAE,gBAAgB,CAAC,EA4ChD;IA/BC;;;OAGG;IACH,kBAAqB;IAYrB;;OAEG;IACH,wBAOY;IAOd;;;;;OAKG;IACH,WAJY,MAAM,CAMjB;IAED;;;;;OAKG;IACH,eAJY,KAAK,CAAC,MAAM,CAAC,CAMxB;IAED;;;;;OAKG;IACH,aAJY,MAAM,CAMjB;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,cAJW,MAAM,QAMhB;IAED;;;;;OAKG;IACH,oBAJW,KAAK,CAAC,MAAM,CAAC,QAMvB;IAED;;;;;OAKG;IACH,kBAJW,MAAM,QAMhB;IAkED;;OAEG;IACH,iCAAoB;CACrB;qCAzPoC,kCAAkC;uBAEhD,iBAAiB"}
+{"version":3,"file":"Heatmap.d.ts","sourceRoot":"","sources":["Heatmap.js"],"names":[],"mappings":";+BAkBa,OAAO,kBAAkB,EAAE,gBAAgB,GAAC,MAAM,IAAC,CAAS,IAA+B,EAA/B,OAAO,eAAe,EAAE,OAAO,KAAE,MAAM,CAAA;oBAI5D,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY,mEACiB,gBAAgB,SAAtE,OAAQ,qBAAqB,EAAE,OAAO,CAAC,WAAW,CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDjE;;;;;;;;;;;;;GAaG;AACH,sBALoD,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY,mEACiB,gBAAgB,SAAtE,OAAQ,qBAAqB,EAAE,OAAO,CAAC,WAAW,CAAE;IAK/D;;OAEG;IACH,sBAFW,OAAO,CAAC,WAAW,EAAE,gBAAgB,CAAC,EA6ChD;IAhCC,sDAAqC;IAErC;;;OAGG;IACH,wBAA8C;IAE9C;;;OAGG;IACH,kBAAqB;IAYrB;;OAEG;IACH,gBAAqB;IAOvB;;;;;OAKG;IACH,WAJY,OAAO,kBAAkB,EAAE,gBAAgB,CAQtD;IAED;;;;;OAKG;IACH,eAJY,KAAK,CAAC,MAAM,CAAC,CAMxB;IAED;;;;;OAKG;IACH,aAJY,OAAO,kBAAkB,EAAE,gBAAgB,CAQtD;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,cAJW,OAAO,kBAAkB,EAAE,gBAAgB,QAarD;IAED;;;;;OAKG;IACH,oBAJW,KAAK,CAAC,MAAM,CAAC,QAMvB;IAED;;;;;OAKG;IACH,kBAJW,OAAO,kBAAkB,EAAE,gBAAgB,QAarD;IAED;;;;OAIG;IACH,kBAHW,OAAO,kBAAkB,EAAE,iBAAiB,QAOtD;IAED;;;;OAIG;IACH,kBAHW,gBAAgB,QAO1B;IAuHD;;;OAGG;IACH,gCAFW,OAAO,kBAAkB,EAAE,cAAc,QAKnD;IAED;;OAEG;IACH,iCAAoB;CACrB;qCAvWoC,kCAAkC;uBAChD,iBAAiB"}

package/layer/Heatmap.js

@@ -2,11 +2,23 @@
  * @module ol/layer/Heatmap
  */
 import {createCanvasContext2D} from '../dom.js';
+import {BooleanType, NumberType} from '../expr/expression.js';
+import {newCompilationContext} from '../expr/gpu.js';
 import {clamp} from '../math.js';
-import WebGLPointsLayerRenderer from '../renderer/webgl/PointsLayer.js';
-import {ShaderBuilder} from '../webgl/ShaderBuilder.js';
+import {ShaderBuilder} from '../render/webgl/ShaderBuilder.js';
+import {
+  applyContextToBuilder,
+  expressionToGlsl,
+  generateAttributesFromContext,
+  generateUniformsFromContext,
+} from '../render/webgl/compileUtil.js';
+import WebGLVectorLayerRenderer from '../renderer/webgl/VectorLayer.js';
 import BaseVector from './BaseVector.js';
 
+/**
+ * @typedef {import("../style/flat.js").NumberExpression|string|function(import("../Feature.js").default):number} WeightExpression
+ */
+
 /**
  * @template {import("../Feature.js").FeatureLike} [FeatureType=import("../Feature.js").default]
  * @template {import("../source/Vector.js").default<FeatureType>} [VectorSourceType=import("../source/Vector.js").default<FeatureType>]
@@ -30,11 +42,15 @@ import BaseVector from './BaseVector.js';
  * be visible.
  * @property {Array<string>} [gradient=['#00f', '#0ff', '#0f0', '#ff0', '#f00']] The color gradient
  * of the heatmap, specified as an array of CSS color strings.
- * @property {number} [radius=8] Radius size in pixels.
- * @property {number} [blur=15] Blur size in pixels.
- * @property {string|function(import("../Feature.js").default):number} [weight='weight'] The feature
- * attribute to use for the weight or a function that returns a weight from a feature. Weight values
+ * @property {import("../style/flat.js").NumberExpression} [radius=8] Radius size in pixels. Note that for LineStrings,
+ * the width of the line will be double the radius.
+ * @property {import("../style/flat.js").NumberExpression} [blur=15] Blur size in pixels. This is added to the `radius`
+ * parameter above to create the final size of the blur effect.
+ * @property {WeightExpression} [weight='weight'] The feature
+ * attribute to use for the weight. This also supports expressions returning a number or a function that returns a weight from a feature. Weight values
  * should range from 0 to 1 (and values outside will be clamped to that range).
+ * @property {import("../style/flat.js").BooleanExpression} [filter] Optional filter expression.
+ * @property {Object<string, number|Array<number>|string|boolean>} [variables] Variables used in expressions (optional)
  * @property {VectorSourceType} [source] Point source.
  * @property {Object<string, *>} [properties] Arbitrary observable properties. Can be accessed with `#get()` and `#set()`.
  */
@@ -66,7 +82,7 @@ const DEFAULT_GRADIENT = ['#00f', '#0ff', '#0f0', '#ff0', '#f00'];
  * @fires import("../render/Event.js").RenderEvent#postrender
  * @template {import("../Feature.js").FeatureLike} [FeatureType=import("../Feature.js").default]
  * @template {import("../source/Vector.js").default<FeatureType>} [VectorSourceType=import("../source/Vector.js").default<FeatureType>]
- * @extends {BaseVector<FeatureType, VectorSourceType, WebGLPointsLayerRenderer>}
+ * @extends {BaseVector<FeatureType, VectorSourceType, WebGLVectorLayerRenderer>}
  * @api
  */
 class Heatmap extends BaseVector {
@@ -84,6 +100,14 @@ class Heatmap extends BaseVector {
     delete baseOptions.weight;
     super(baseOptions);
 
+    this.filter_ = options.filter ?? true;
+
+    /**
+     * @type {import('../style/flat.js').StyleVariables}
+     * @private
+     */
+    this.styleVariables_ = options.variables || {};
+
     /**
      * @private
      * @type {HTMLCanvasElement}
@@ -103,14 +127,7 @@ class Heatmap extends BaseVector {
     /**
      * @private
      */
-    this.weightFunction_ =
-      typeof weight === 'string'
-        ? /**
-           * @param {import('../Feature.js').default} feature Feature
-           * @return {any} weight
-           */
-          (feature) => feature.get(weight)
-        : weight;
+    this.weight_ = weight;
 
     // For performance reasons, don't sort the features before rendering.
     // The render order is not relevant for a heatmap representation.
@@ -119,12 +136,14 @@ class Heatmap extends BaseVector {
 
   /**
    * Return the blur size in pixels.
-   * @return {number} Blur size in pixels.
+   * @return {import("../style/flat.js").NumberExpression} Blur size in pixels.
    * @api
    * @observable
    */
   getBlur() {
-    return /** @type {number} */ (this.get(Property.BLUR));
+    return /** @type {import("../style/flat.js").NumberExpression} */ (
+      this.get(Property.BLUR)
+    );
   }
 
   /**
@@ -139,12 +158,14 @@ class Heatmap extends BaseVector {
 
   /**
    * Return the size of the radius in pixels.
-   * @return {number} Radius size in pixel.
+   * @return {import("../style/flat.js").NumberExpression} Radius size in pixel.
    * @api
    * @observable
    */
   getRadius() {
-    return /** @type {number} */ (this.get(Property.RADIUS));
+    return /** @type {import("../style/flat.js").NumberExpression} */ (
+      this.get(Property.RADIUS)
+    );
   }
 
   /**
@@ -156,12 +177,19 @@ class Heatmap extends BaseVector {
 
   /**
    * Set the blur size in pixels.
-   * @param {number} blur Blur size in pixels.
+   * @param {import("../style/flat.js").NumberExpression} blur Blur size in pixels (supports expressions).
    * @api
    * @observable
    */
   setBlur(blur) {
+    const previousValue = this.get(Property.BLUR);
     this.set(Property.BLUR, blur);
+    // if the value stays numerical, simply refresh the layer
+    if (typeof blur === 'number' && typeof previousValue === 'number') {
+      this.changed();
+      return;
+    }
+    this.clearRenderer();
   }
 
   /**
@@ -176,52 +204,134 @@ class Heatmap extends BaseVector {
 
   /**
    * Set the size of the radius in pixels.
-   * @param {number} radius Radius size in pixel.
+   * @param {import("../style/flat.js").NumberExpression} radius Radius size in pixel (supports expressions).
    * @api
    * @observable
    */
   setRadius(radius) {
+    const previousValue = this.get(Property.RADIUS);
     this.set(Property.RADIUS, radius);
+    // if the value stays numerical, simply refresh the layer
+    if (typeof radius === 'number' && typeof previousValue === 'number') {
+      this.changed();
+      return;
+    }
+    this.clearRenderer();
+  }
+
+  /**
+   * Set the filter expression
+   * @param {import("../style/flat.js").BooleanExpression} filter Filter expression
+   * @api
+   */
+  setFilter(filter) {
+    this.filter_ = filter;
+    this.changed();
+    this.clearRenderer();
+  }
+
+  /**
+   * Set the weight expression
+   * @param {WeightExpression} weight Weight expression
+   * @api
+   */
+  setWeight(weight) {
+    this.weight_ = weight;
+    this.changed();
+    this.clearRenderer();
   }
 
   /**
    * @override
    */
   createRenderer() {
-    const builder = new ShaderBuilder()
-      .addAttribute('float a_weight')
-      .addVarying('v_weight', 'float', 'a_weight')
-      .addUniform('float u_size')
-      .addUniform('float u_blurSlope')
-      .setSymbolSizeExpression('vec2(u_size)')
+    const builder = new ShaderBuilder();
+
+    const context = newCompilationContext();
+    const filterCompiled = expressionToGlsl(context, this.filter_, BooleanType);
+    let radiusCompiled = expressionToGlsl(
+      context,
+      this.getRadius(),
+      NumberType,
+    );
+    let blurCompiled = expressionToGlsl(context, this.getBlur(), NumberType);
+
+    /** @type {import('../render/webgl/VectorStyleRenderer.js').UniformDefinitions} */
+    const blurRadiusUniforms = {};
+    if (typeof this.getBlur() === 'number') {
+      blurCompiled = 'a_blur';
+      blurRadiusUniforms['a_blur'] = () => this.getBlur();
+      builder.addUniform('float a_blur');
+    }
+    if (typeof this.getRadius() === 'number') {
+      radiusCompiled = 'a_radius';
+      blurRadiusUniforms['a_radius'] = () => this.getRadius();
+      builder.addUniform('float a_radius');
+    }
+
+    /** @type {import('../render/webgl/VectorStyleRenderer.js').AttributeDefinitions} */
+    const weightAttribute = {};
+    let weightExpression = null;
+    if (
+      typeof this.weight_ === 'string' ||
+      typeof this.weight_ === 'function'
+    ) {
+      const weightFunction =
+        typeof this.weight_ === 'string'
+          ? (feature) => feature.get(this.weight_)
+          : this.weight_;
+      weightAttribute['prop_weight'] = {
+        size: 1,
+        callback: (feature) => {
+          const weightValue = weightFunction(feature);
+          return weightValue !== undefined ? clamp(weightValue, 0, 1) : 1;
+        },
+      };
+      weightExpression = 'a_prop_weight';
+      builder.addAttribute('a_prop_weight', 'float');
+    } else {
+      const clampedWeight = ['clamp', this.weight_, 0, 1];
+      weightExpression = expressionToGlsl(context, clampedWeight, NumberType);
+    }
+
+    builder
+      .addFragmentShaderFunction(
+        `float getBlurSlope() {
+  float blur = max(1., ${blurCompiled});
+  float radius = ${radiusCompiled};
+  return radius / blur;
+}`,
+      )
+      .setSymbolSizeExpression(`vec2(${radiusCompiled} + ${blurCompiled}) * 2.`)
       .setSymbolColorExpression(
-        'vec4(smoothstep(0., 1., (1. - length(coordsPx * 2. / v_quadSizePx)) * u_blurSlope) * v_weight)',
-      );
-
-    return new WebGLPointsLayerRenderer(this, {
+        `vec4(smoothstep(0., 1., (1. - length(coordsPx * 2. / v_quadSizePx)) * getBlurSlope()) * ${weightExpression})`,
+      )
+      .setStrokeColorExpression(
+        `vec4(smoothstep(0., 1., (1. - length(currentRadiusPx * 2. / v_width)) * getBlurSlope()) * ${weightExpression})`,
+      )
+      .setStrokeWidthExpression(`(${radiusCompiled} + ${blurCompiled}) * 2.`)
+      .setFillColorExpression(`vec4(${weightExpression})`)
+      .setFragmentDiscardExpression(`!${filterCompiled}`);
+
+    applyContextToBuilder(builder, context);
+    const attributes = generateAttributesFromContext(context);
+    const uniforms = generateUniformsFromContext(context, this.styleVariables_);
+
+    return new WebGLVectorLayerRenderer(this, {
       className: this.getClassName(),
-      attributes: [
-        {
-          name: 'weight',
-          callback: (feature) => {
-            const weight = this.weightFunction_(feature);
-            return weight !== undefined ? clamp(weight, 0, 1) : 1;
-          },
-        },
-      ],
-      uniforms: {
-        u_size: () => {
-          return (this.get(Property.RADIUS) + this.get(Property.BLUR)) * 2;
+      variables: this.styleVariables_,
+      style: {
+        builder,
+        attributes: {
+          ...attributes,
+          ...weightAttribute,
         },
-        u_blurSlope: () => {
-          return (
-            this.get(Property.RADIUS) / Math.max(1, this.get(Property.BLUR))
-          );
+        uniforms: {
+          ...uniforms,
+          ...blurRadiusUniforms,
         },
       },
-      hitDetectionEnabled: true,
-      vertexShader: builder.getSymbolVertexShader(),
-      fragmentShader: builder.getSymbolFragmentShader(),
+      disableHitDetection: false,
       postProcesses: [
         {
           fragmentShader: `
@@ -248,6 +358,15 @@ class Heatmap extends BaseVector {
     });
   }
 
+  /**
+   * Update any variables used by the layer style and trigger a re-render.
+   * @param {import('../style/flat.js').StyleVariables} variables Variables to update.
+   */
+  updateStyleVariables(variables) {
+    Object.assign(this.styleVariables_, variables);
+    this.changed();
+  }
+
   /**
    * @override
    */

package/layer/WebGLPoints.d.ts

@@ -158,7 +158,7 @@ declare class WebGLPointsLayer<VectorSourceType extends import("../source/Vector
     private styleVariables_;
     /**
      * @private
-     * @type {import('../webgl/styleparser.js').StyleParseResult}
+     * @type {import('../render/webgl/style.js').StyleParseResult}
      */
     private parseResult_;
     /**

package/layer/WebGLPoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebGLPoints.d.ts","sourceRoot":"","sources":["WebGLPoints.js"],"names":[],"mappings":";oBAQuF,gBAAgB,SAA1F,OAAQ,qBAAqB,EAAE,OAAO,CAAC,OAAO,YAAY,EAAE,WAAW,CAAE;;;;WAExE,OAAO,kBAAkB,EAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAHlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,+BANuF,gBAAgB,SAA1F,OAAQ,qBAAqB,EAAE,OAAO,CAAC,OAAO,YAAY,EAAE,WAAW,CAAE;IAOpF;;OAEG;IACH,qBAFW,OAAO,CAAC,gBAAgB,CAAC,EA4BnC;IArBC;;;OAGG;IACH,wBAA8C;IAE9C;;;OAGG;IACH,qBAIC;IAED;;;OAGG;IACH,8BAA0D;IAyB5D;;;OAGG;IACH;;aAGC;CACF;qCAvIoC,kCAAkC;kBAErD,YAAY"}
+{"version":3,"file":"WebGLPoints.d.ts","sourceRoot":"","sources":["WebGLPoints.js"],"names":[],"mappings":";oBAQuF,gBAAgB,SAA1F,OAAQ,qBAAqB,EAAE,OAAO,CAAC,OAAO,YAAY,EAAE,WAAW,CAAE;;;;WAExE,OAAO,kBAAkB,EAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAHlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,+BANuF,gBAAgB,SAA1F,OAAQ,qBAAqB,EAAE,OAAO,CAAC,OAAO,YAAY,EAAE,WAAW,CAAE;IAOpF;;OAEG;IACH,qBAFW,OAAO,CAAC,gBAAgB,CAAC,EA4BnC;IArBC;;;OAGG;IACH,wBAA8C;IAE9C;;;OAGG;IACH,qBAIC;IAED;;;OAGG;IACH,8BAA0D;IAyB5D;;;OAGG;IACH;;aAGC;CACF;qCAtIoC,kCAAkC;kBACrD,YAAY"}

package/layer/WebGLPoints.js

@@ -1,8 +1,8 @@
 /**
  * @module ol/layer/WebGLPoints
  */
+import {parseLiteralStyle} from '../render/webgl/style.js';
 import WebGLPointsLayerRenderer from '../renderer/webgl/PointsLayer.js';
-import {parseLiteralStyle} from '../webgl/styleparser.js';
 import Layer from './Layer.js';
 
 /**
@@ -91,7 +91,7 @@ class WebGLPointsLayer extends Layer {
 
     /**
      * @private
-     * @type {import('../webgl/styleparser.js').StyleParseResult}
+     * @type {import('../render/webgl/style.js').StyleParseResult}
      */
     this.parseResult_ = parseLiteralStyle(
       options.style,