ol 10.3.2-dev.1734966546937 → 10.3.2-dev.1735553764538

package/layer/WebGLPoints.d.ts

@@ -3,7 +3,12 @@ export type Options<VectorSourceType extends import("../source/Vector.js").defau
     /**
      * Literal style to apply to the layer features.
      */
-    style: import("../style/webgl.js").WebGLStyle;
+    style: import("../style/flat.js").FlatStyle;
+    /**
+     * The filter used
+     * to determine if a style applies. If no filter is included, the rule always applies.
+     */
+    filter?: import("../expr/expression.js").EncodedExpression | undefined;
     /**
      * Style variables. Each variable must hold a literal value (not
      * an expression). These variables can be used as {@link import ("../expr/expression.js").ExpressionValue expressions} in the styles properties
@@ -76,7 +81,9 @@ export type Options<VectorSourceType extends import("../source/Vector.js").defau
 /**
  * @template {import("../source/Vector.js").default<import('../Feature').FeatureLike>} VectorSourceType
  * @typedef {Object} Options
- * @property {import('../style/webgl.js').WebGLStyle} style Literal style to apply to the layer features.
+ * @property {import('../style/flat.js').FlatStyle} style Literal style to apply to the layer features.
+ * @property {import("../expr/expression.js").EncodedExpression} [filter] The filter used
+ * to determine if a style applies. If no filter is included, the rule always applies.
  * @property {import('../style/flat.js').StyleVariables} [variables] Style variables. Each variable must hold a literal value (not
  * an expression). These variables can be used as {@link import("../expr/expression.js").ExpressionValue expressions} in the styles properties
  * using the `['var', 'varName']` operator.

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,mBAAmB,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAHpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,+BALuF,gBAAgB,SAA1F,OAAQ,qBAAqB,EAAE,OAAO,CAAC,OAAO,YAAY,EAAE,WAAW,CAAE;IAMpF;;OAEG;IACH,qBAFW,OAAO,CAAC,gBAAgB,CAAC,EAwBnC;IAjBC;;;OAGG;IACH,wBAA8C;IAE9C;;;OAGG;IACH,qBAA0E;IAE1E;;;OAGG;IACH,8BAA0D;IAyB5D;;;OAGG;IACH;;aAGC;CACF;qCAhIoC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,+BALuF,gBAAgB,SAA1F,OAAQ,qBAAqB,EAAE,OAAO,CAAC,OAAO,YAAY,EAAE,WAAW,CAAE;IAMpF;;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;kBAErD,YAAY"}

package/layer/WebGLPoints.js

@@ -8,7 +8,9 @@ import Layer from './Layer.js';
 /**
  * @template {import("../source/Vector.js").default<import('../Feature').FeatureLike>} VectorSourceType
  * @typedef {Object} Options
- * @property {import('../style/webgl.js').WebGLStyle} style Literal style to apply to the layer features.
+ * @property {import('../style/flat.js').FlatStyle} style Literal style to apply to the layer features.
+ * @property {import("../expr/expression.js").EncodedExpression} [filter] The filter used
+ * to determine if a style applies. If no filter is included, the rule always applies.
  * @property {import('../style/flat.js').StyleVariables} [variables] Style variables. Each variable must hold a literal value (not
  * an expression). These variables can be used as {@link import("../expr/expression.js").ExpressionValue expressions} in the styles properties
  * using the `['var', 'varName']` operator.
@@ -90,7 +92,11 @@ class WebGLPointsLayer extends Layer {
      * @private
      * @type {import('../webgl/styleparser.js').StyleParseResult}
      */
-    this.parseResult_ = parseLiteralStyle(options.style, this.styleVariables_);
+    this.parseResult_ = parseLiteralStyle(
+      options.style,
+      this.styleVariables_,
+      options.filter,
+    );
 
     /**
      * @private

package/layer/WebGLVector.d.ts

@@ -56,7 +56,7 @@ export type Options<VectorSourceType extends import("../source/Vector.js").defau
     /**
      * Layer style.
      */
-    style: import("../style/webgl.js").WebGLStyle;
+    style: import("../style/flat.js").FlatStyleLike;
     /**
      * Style variables. Each variable must hold a literal value (not
      * an expression). These variables can be used as {@link import ("../expr/expression.js").ExpressionValue expressions} in the styles properties
@@ -111,7 +111,7 @@ export type Options<VectorSourceType extends import("../source/Vector.js").defau
  * @property {number} [maxZoom] The maximum view zoom level (inclusive) at which this layer will
  * be visible.
  * @property {VectorSourceType} [source] Source.
- * @property {import('../style/webgl.js').WebGLStyle} style Layer style.
+ * @property {import('../style/flat.js').FlatStyleLike} style Layer style.
  * @property {import('../style/flat.js').StyleVariables} [variables] Style variables. Each variable must hold a literal value (not
  * an expression). These variables can be used as {@link import("../expr/expression.js").ExpressionValue expressions} in the styles properties
  * using the `['var', 'varName']` operator.
@@ -163,10 +163,10 @@ declare class WebGLVectorLayer<VectorSourceType extends import("../source/Vector
     updateStyleVariables(variables: import("../style/flat.js").StyleVariables): void;
     /**
      * Set the layer style.
-     * @param {import('../style/webgl.js').WebGLStyle} style Layer style.
+     * @param {import('../style/flat.js').FlatStyleLike} style Layer style.
      */
-    setStyle(style: import("../style/webgl.js").WebGLStyle): void;
-    style: import("../style/webgl.js").WebGLStyle | undefined;
+    setStyle(style: import("../style/flat.js").FlatStyleLike): void;
+    style: import("../style/flat.js").FlatStyleLike | undefined;
 }
 import WebGLVectorLayerRenderer from '../renderer/webgl/VectorLayer.js';
 import Layer from './Layer.js';

package/layer/WebGLVector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebGLVector.d.ts","sourceRoot":"","sources":["WebGLVector.js"],"names":[],"mappings":";;;;iCAOa,CAAC,IACD,CAAC,SAAS,OAAO,qBAAqB,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,OAAO,eAAe,EAAE,WAAW,CAAC,GAAG,CAAC,GAAG,KAAK;oBAI1D,gBAAgB,SAAtE,OAAQ,qBAAqB,EAAE,OAAO,CAAC,WAAW,CAAE,+CACb,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAqBpC,OAAO,mBAAmB,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA5BpD;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;;;;;;;;;GAcG;AACH,+BAJmE,gBAAgB,SAAtE,OAAQ,qBAAqB,EAAE,OAAO,CAAC,WAAW,CAAE,+CACb,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY;IAIhD;;OAEG;IACH,sBAFW,OAAO,CAAC,gBAAgB,EAAE,WAAW,CAAC,EAsBhD;IAfC;;;OAGG;IACH,wBAA8C;IAE9C;;OAEG;IACH,eAA2B;IAE3B;;OAEG;IACH,8BAA0D;IAc5D;;;OAGG;IACH,gCAFW,OAAO,kBAAkB,EAAE,cAAc,QAKnD;IAED;;;OAGG;IACH,gBAFW,OAAO,mBAAmB,EAAE,UAAU,QAMhD;IAHC,0DAAkB;CAIrB;qCAlHoC,kCAAkC;kBACrD,YAAY"}
+{"version":3,"file":"WebGLVector.d.ts","sourceRoot":"","sources":["WebGLVector.js"],"names":[],"mappings":";;;;iCAOa,CAAC,IACD,CAAC,SAAS,OAAO,qBAAqB,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,OAAO,eAAe,EAAE,WAAW,CAAC,GAAG,CAAC,GAAG,KAAK;oBAI1D,gBAAgB,SAAtE,OAAQ,qBAAqB,EAAE,OAAO,CAAC,WAAW,CAAE,+CACb,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAqBpC,OAAO,kBAAkB,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA5BtD;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;;;;;;;;;GAcG;AACH,+BAJmE,gBAAgB,SAAtE,OAAQ,qBAAqB,EAAE,OAAO,CAAC,WAAW,CAAE,+CACb,WAAW,SAAlD,OAAQ,eAAe,EAAE,WAAY;IAIhD;;OAEG;IACH,sBAFW,OAAO,CAAC,gBAAgB,EAAE,WAAW,CAAC,EAsBhD;IAfC;;;OAGG;IACH,wBAA8C;IAE9C;;OAEG;IACH,eAA2B;IAE3B;;OAEG;IACH,8BAA0D;IAc5D;;;OAGG;IACH,gCAFW,OAAO,kBAAkB,EAAE,cAAc,QAKnD;IAED;;;OAGG;IACH,gBAFW,OAAO,kBAAkB,EAAE,aAAa,QAMlD;IAHC,4DAAkB;CAIrB;qCAlHoC,kCAAkC;kBACrD,YAAY"}

package/layer/WebGLVector.js

@@ -32,7 +32,7 @@ import Layer from './Layer.js';
  * @property {number} [maxZoom] The maximum view zoom level (inclusive) at which this layer will
  * be visible.
  * @property {VectorSourceType} [source] Source.
- * @property {import('../style/webgl.js').WebGLStyle} style Layer style.
+ * @property {import('../style/flat.js').FlatStyleLike} style Layer style.
  * @property {import('../style/flat.js').StyleVariables} [variables] Style variables. Each variable must hold a literal value (not
  * an expression). These variables can be used as {@link import("../expr/expression.js").ExpressionValue expressions} in the styles properties
  * using the `['var', 'varName']` operator.
@@ -108,7 +108,7 @@ class WebGLVectorLayer extends Layer {
 
   /**
    * Set the layer style.
-   * @param {import('../style/webgl.js').WebGLStyle} style Layer style.
+   * @param {import('../style/flat.js').FlatStyleLike} style Layer style.
    */
   setStyle(style) {
     this.style = style;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ol",
-  "version": "10.3.2-dev.1734966546937",
+  "version": "10.3.2-dev.1735553764538",
   "description": "OpenLayers mapping library",
   "keywords": [
     "map",

package/render/webgl/VectorStyleRenderer.d.ts

@@ -82,7 +82,7 @@ export type ShaderProgram = {
      */
     fragment: string;
 };
-export type StyleShaders = {
+export type AsShaders = {
     /**
      * Shader builder with the appropriate presets.
      */
@@ -101,7 +101,17 @@ export type StyleShaders = {
         [x: string]: import("../../webgl/Helper.js").UniformValue;
     } | undefined;
 };
-export type VectorStyle = import("../../style/webgl.js").WebGLStyle | StyleShaders;
+export type AsRule = {
+    /**
+     * Style
+     */
+    style: import("../../style/flat.js").FlatStyle;
+    /**
+     * Filter
+     */
+    filter?: import("../../expr/expression.js").EncodedExpression | undefined;
+};
+export type VectorStyle = AsRule | AsShaders;
 /**
  * @typedef {Object} AttributeDefinition A description of a custom attribute to be passed on to the GPU, with a value different
  * for each feature.
@@ -133,14 +143,19 @@ export type VectorStyle = import("../../style/webgl.js").WebGLStyle | StyleShade
  * @property {string} fragment Fragment shader source
  */
 /**
- * @typedef {Object} StyleShaders
+ * @typedef {Object} AsShaders
  * @property {import("../../webgl/ShaderBuilder.js").ShaderBuilder} builder Shader builder with the appropriate presets.
  * @property {AttributeDefinitions} [attributes] Custom attributes made available in the vertex shaders.
  * Default shaders rely on the attributes in {@link Attributes}.
  * @property {UniformDefinitions} [uniforms] Additional uniforms usable in shaders.
  */
 /**
- * @typedef {import('../../style/webgl.js').WebGLStyle|StyleShaders} VectorStyle
+ * @typedef {Object} AsRule
+ * @property {import('../../style/flat.js').FlatStyle} style Style
+ * @property {import("../../expr/expression.js").EncodedExpression} [filter] Filter
+ */
+/**
+ * @typedef {AsRule|AsShaders} VectorStyle
  */
 /**
  * @classdesc This class is responsible for:
@@ -161,9 +176,9 @@ declare class VectorStyleRenderer {
      * @param {VectorStyle} styleOrShaders Literal style or custom shaders
      * @param {import('../../style/flat.js').StyleVariables} variables Style variables
      * @param {import('../../webgl/Helper.js').default} helper Helper
-     * @param {boolean} enableHitDetection Whether to enable the hit detection (needs compatible shader)
+     * @param {boolean} [enableHitDetection] Whether to enable the hit detection (needs compatible shader)
      */
-    constructor(styleOrShaders: VectorStyle, variables: import("../../style/flat.js").StyleVariables, helper: import("../../webgl/Helper.js").default, enableHitDetection: boolean);
+    constructor(styleOrShaders: VectorStyle, variables: import("../../style/flat.js").StyleVariables, helper: import("../../webgl/Helper.js").default, enableHitDetection?: boolean);
     /**
      * @private
      * @type {import('../../webgl/Helper.js').default}

package/render/webgl/VectorStyleRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VectorStyleRenderer.d.ts","sourceRoot":"","sources":["VectorStyleRenderer.js"],"names":[],"mappings":";;;;yBAmCU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmBF,CAAS,IAAwD,EAAnD,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,IAAmC,EAAnC,OAAO,eAAe,EAAE,WAAW,KAAE,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC;;;;;;;;;;;;oBAW5H,KAAK,CAAC,gBAAgB,CAAC;;;;uBACvB,KAAK,CAAC,gBAAgB,CAAC;;;;kBACvB,KAAK,CAAC,gBAAgB,CAAC;;;;6BACvB,OAAO,oBAAoB,EAAE,SAAS;;;;;;yBAKtC,YAAY,GAAC,IAAI;;;;4BACjB,YAAY,GAAC,IAAI;;;;uBACjB,YAAY,GAAC,IAAI;;;;;;;;;YAKjB,MAAM;;;;cACN,MAAM;;;;;;aAKN,OAAO,8BAA8B,EAAE,aAAa;;;;;;;;;;;;;;;0BAOrD,OAAO,sBAAsB,EAAE,UAAU,GAAC,YAAY;AA5CnE;;;;;;;GAOG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH;IACE;;;;;OAKG;IACH,4BALW,WAAW,aACX,OAAO,qBAAqB,EAAE,cAAc,UAC5C,OAAO,uBAAuB,EAAE,OAAO,sBACvC,OAAO,EAuMjB;IApMC;;;OAGG;IACH,gBAAY;IAEZ;;OAEG;IACH,6BAA8C;IAiB9C;;;OAGG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,uBAAmB;IAEnB;;;OAGG;IACH,uBAAmB;IAEnB;;;OAGG;IACH,iBAAuD;IAErD;;OAEG;IACH,0BAA8D;IAC9D;;OAEG;IACH,4BAAkE;IAGpE;;;OAGG;IACH,mBAA2D;IAEzD;;OAEG;IACH,4BAAkE;IAClE;;OAEG;IACH,8BAAsE;IAGxE;;;OAGG;IACH,mBAA2D;IAEzD;;OAEG;IACH,4BAAkE;IAClE;;OAEG;IACH,8BAAsE;IAcxE;;OAEG;IACH,0BAIC;IACD;;OAEG;IACH,kBAAiC;IASjC;;;OAGG;IACH,+BAOC;IACD;;;OAGG;IACH,kCAqCC;IACD;;;OAGG;IACH,6BAYC;IAKH;;;;OAIG;IACH,+BAJW,OAAO,yBAAyB,EAAE,OAAO,aACzC,OAAO,oBAAoB,EAAE,SAAS,GACrC,OAAO,CAAC,YAAY,CAAC,CAqChC;IAED;;;;;OAKG;IACH,oCA+BC;IAED;;;;;;OAMG;IACH,gCAwEC;IAED;;;;;OAKG;IACH,gBAJW,YAAY,cACZ,OAAO,cAAc,EAAE,UAAU,qBACjC,MAAY,IAAI,QA8B1B;IAED;;;;;;;;OAQG;IACH,wBAkBC;IAED;;;OAGG;IACH,kBAHW,OAAO,uBAAuB,EAAE,OAAO,YACvC,YAAY,QAuCtB;CACF;6BAlkB4B,uBAAuB"}
+{"version":3,"file":"VectorStyleRenderer.d.ts","sourceRoot":"","sources":["VectorStyleRenderer.js"],"names":[],"mappings":";;;;yBAmCU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmBF,CAAS,IAAwD,EAAnD,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,IAAmC,EAAnC,OAAO,eAAe,EAAE,WAAW,KAAE,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC;;;;;;;;;;;;oBAW5H,KAAK,CAAC,gBAAgB,CAAC;;;;uBACvB,KAAK,CAAC,gBAAgB,CAAC;;;;kBACvB,KAAK,CAAC,gBAAgB,CAAC;;;;6BACvB,OAAO,oBAAoB,EAAE,SAAS;;;;;;yBAKtC,YAAY,GAAC,IAAI;;;;4BACjB,YAAY,GAAC,IAAI;;;;uBACjB,YAAY,GAAC,IAAI;;;;;;;;;YAKjB,MAAM;;;;cACN,MAAM;;;;;;aAKN,OAAO,8BAA8B,EAAE,aAAa;;;;;;;;;;;;;;;;;;;WAQpD,OAAO,qBAAqB,EAAE,SAAS;;;;;;0BAKxC,MAAM,GAAC,SAAS;AAlD7B;;;;;;;GAOG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;GAIG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH;IACE;;;;;OAKG;IACH,4BALW,WAAW,aACX,OAAO,qBAAqB,EAAE,cAAc,UAC5C,OAAO,uBAAuB,EAAE,OAAO,uBACvC,OAAO,EAwMjB;IArMC;;;OAGG;IACH,gBAAY;IAEZ;;OAEG;IACH,6BAAgD;IAkBhD;;;OAGG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,uBAAmB;IAEnB;;;OAGG;IACH,uBAAmB;IAEnB;;;OAGG;IACH,iBAAyD;IAEvD;;OAEG;IACH,0BAAgE;IAChE;;OAEG;IACH,4BAAoE;IAGtE;;;OAGG;IACH,mBAA6D;IAE3D;;OAEG;IACH,4BAAoE;IACpE;;OAEG;IACH,8BAAwE;IAG1E;;;OAGG;IACH,mBAA6D;IAE3D;;OAEG;IACH,4BAAoE;IACpE;;OAEG;IACH,8BAAwE;IAc1E;;OAEG;IACH,0BAIC;IACD;;OAEG;IACH,kBAAmC;IASnC;;;OAGG;IACH,+BAOC;IACD;;;OAGG;IACH,kCAqCC;IACD;;;OAGG;IACH,6BAYC;IAKH;;;;OAIG;IACH,+BAJW,OAAO,yBAAyB,EAAE,OAAO,aACzC,OAAO,oBAAoB,EAAE,SAAS,GACrC,OAAO,CAAC,YAAY,CAAC,CAqChC;IAED;;;;;OAKG;IACH,oCA+BC;IAED;;;;;;OAMG;IACH,gCAwEC;IAED;;;;;OAKG;IACH,gBAJW,YAAY,cACZ,OAAO,cAAc,EAAE,UAAU,qBACjC,MAAY,IAAI,QA8B1B;IAED;;;;;;;;OAQG;IACH,wBAkBC;IAED;;;OAGG;IACH,kBAHW,OAAO,uBAAuB,EAAE,OAAO,YACvC,YAAY,QAuCtB;CACF;6BAzkB4B,uBAAuB"}

package/render/webgl/VectorStyleRenderer.js

@@ -83,7 +83,7 @@ export const Attributes = {
  */
 
 /**
- * @typedef {Object} StyleShaders
+ * @typedef {Object} AsShaders
  * @property {import("../../webgl/ShaderBuilder.js").ShaderBuilder} builder Shader builder with the appropriate presets.
  * @property {AttributeDefinitions} [attributes] Custom attributes made available in the vertex shaders.
  * Default shaders rely on the attributes in {@link Attributes}.
@@ -91,7 +91,13 @@ export const Attributes = {
  */
 
 /**
- * @typedef {import('../../style/webgl.js').WebGLStyle|StyleShaders} VectorStyle
+ * @typedef {Object} AsRule
+ * @property {import('../../style/flat.js').FlatStyle} style Style
+ * @property {import("../../expr/expression.js").EncodedExpression} [filter] Filter
+ */
+
+/**
+ * @typedef {AsRule|AsShaders} VectorStyle
  */
 
 /**
@@ -113,7 +119,7 @@ class VectorStyleRenderer {
    * @param {VectorStyle} styleOrShaders Literal style or custom shaders
    * @param {import('../../style/flat.js').StyleVariables} variables Style variables
    * @param {import('../../webgl/Helper.js').default} helper Helper
-   * @param {boolean} enableHitDetection Whether to enable the hit detection (needs compatible shader)
+   * @param {boolean} [enableHitDetection] Whether to enable the hit detection (needs compatible shader)
    */
   constructor(styleOrShaders, variables, helper, enableHitDetection) {
     /**
@@ -125,17 +131,18 @@ class VectorStyleRenderer {
     /**
      * @private
      */
-    this.hitDetectionEnabled_ = enableHitDetection;
-    let shaders = /** @type {StyleShaders} */ (styleOrShaders);
+    this.hitDetectionEnabled_ = !!enableHitDetection;
+
+    let asShaders = /** @type {AsShaders} */ (styleOrShaders);
     const isShaders = 'builder' in styleOrShaders;
     if (!isShaders) {
+      const asRule = /** @type {AsRule} */ (styleOrShaders);
       const parseResult = parseLiteralStyle(
-        /** @type {import('../../style/webgl.js').WebGLStyle} */ (
-          styleOrShaders
-        ),
+        asRule.style,
         variables,
+        asRule.filter,
       );
-      shaders = {
+      asShaders = {
         builder: parseResult.builder,
         attributes: parseResult.attributes,
         uniforms: parseResult.uniforms,
@@ -164,48 +171,48 @@ class VectorStyleRenderer {
      * @type {boolean}
      * @private
      */
-    this.hasFill_ = !!shaders.builder.getFillVertexShader();
+    this.hasFill_ = !!asShaders.builder.getFillVertexShader();
     if (this.hasFill_) {
       /**
        * @private
        */
-      this.fillVertexShader_ = shaders.builder.getFillVertexShader();
+      this.fillVertexShader_ = asShaders.builder.getFillVertexShader();
       /**
        * @private
        */
-      this.fillFragmentShader_ = shaders.builder.getFillFragmentShader();
+      this.fillFragmentShader_ = asShaders.builder.getFillFragmentShader();
     }
 
     /**
      * @type {boolean}
      * @private
      */
-    this.hasStroke_ = !!shaders.builder.getStrokeVertexShader();
+    this.hasStroke_ = !!asShaders.builder.getStrokeVertexShader();
     if (this.hasStroke_) {
       /**
        * @private
        */
-      this.strokeVertexShader_ = shaders.builder.getStrokeVertexShader();
+      this.strokeVertexShader_ = asShaders.builder.getStrokeVertexShader();
       /**
        * @private
        */
-      this.strokeFragmentShader_ = shaders.builder.getStrokeFragmentShader();
+      this.strokeFragmentShader_ = asShaders.builder.getStrokeFragmentShader();
     }
 
     /**
      * @type {boolean}
      * @private
      */
-    this.hasSymbol_ = !!shaders.builder.getSymbolVertexShader();
+    this.hasSymbol_ = !!asShaders.builder.getSymbolVertexShader();
     if (this.hasSymbol_) {
       /**
        * @private
        */
-      this.symbolVertexShader_ = shaders.builder.getSymbolVertexShader();
+      this.symbolVertexShader_ = asShaders.builder.getSymbolVertexShader();
       /**
        * @private
        */
-      this.symbolFragmentShader_ = shaders.builder.getSymbolFragmentShader();
+      this.symbolFragmentShader_ = asShaders.builder.getSymbolFragmentShader();
     }
 
     const hitDetectionAttributes = this.hitDetectionEnabled_
@@ -225,12 +232,12 @@ class VectorStyleRenderer {
     this.customAttributes_ = Object.assign(
       {},
       hitDetectionAttributes,
-      shaders.attributes,
+      asShaders.attributes,
     );
     /**
      * @private
      */
-    this.uniforms_ = shaders.uniforms;
+    this.uniforms_ = asShaders.uniforms;
 
     const customAttributesDesc = Object.entries(this.customAttributes_).map(
       ([name, value]) => ({

package/render/webgl/utils.d.ts

@@ -82,7 +82,22 @@ export function colorEncodeId(id: number, array?: Array<number>): Array<number>;
  * @return {number} Decoded id
  */
 export function colorDecodeId(color: Array<number>): number;
+/**
+ * @typedef {import('./VectorStyleRenderer.js').AsShaders} StyleAsShaders
+ */
+/**
+ * @typedef {import('./VectorStyleRenderer.js').AsRule} StyleAsRule
+ */
+/**
+ * Takes in either a Flat Style or an array of shaders (used as input for the webgl vector layer classes)
+ * and breaks it down into separate styles to be used by the VectorStyleRenderer class.
+ * @param {import('../../style/flat.js').FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders} style Flat style or shaders
+ * @return {Array<StyleAsShaders | StyleAsRule>} Separate styles as shaders or rules with a single flat style and a filter
+ */
+export function breakDownFlatStyle(style: import("../../style/flat.js").FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders): Array<StyleAsShaders | StyleAsRule>;
 export const LINESTRING_ANGLE_COSINE_CUTOFF: 0.985;
+export type StyleAsShaders = import("./VectorStyleRenderer.js").AsShaders;
+export type StyleAsRule = import("./VectorStyleRenderer.js").AsRule;
 /**
  * An object holding positions both in an index and a vertex buffer.
  */

package/render/webgl/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;GAYG;AACH,yDAXW,YAAY,gBACZ,MAAM,gBACN,YAAY,eACZ,WAAW,wBACX,MAAM,oBACN,eAAe,GACd,eAAe,CAgE1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wDAdW,YAAY,qBACZ,MAAM,mBACN,MAAM,sBACN,MAAM,GAAC,IAAI,qBACX,MAAM,GAAC,IAAI,eACX,KAAK,CAAC,MAAM,CAAC,cACb,KAAK,CAAC,MAAM,CAAC,oBACb,KAAK,CAAC,MAAM,CAAC,oBACb,OAAO,oBAAoB,EAAE,SAAS,iBACtC,MAAM,0BACN,MAAM,GACL;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAgM1C;AAED;;;;;;;;;GASG;AACH,6DARW,YAAY,qBACZ,MAAM,eACN,KAAK,CAAC,MAAM,CAAC,cACb,KAAK,CAAC,MAAM,CAAC,wBACb,MAAM,GACL,MAAM,CA0CjB;AAED;;;;GAIG;AACH,qCAFY,SAAS,CAUpB;AAED;;;;;;GAMG;AACH,kCAJW,MAAM,UACN,KAAK,CAAC,MAAM,CAAC,GACZ,KAAK,CAAC,MAAM,CAAC,CAWxB;AAED;;;;;GAKG;AACH,qCAHW,KAAK,CAAC,MAAM,CAAC,GACZ,MAAM,CAWjB;AAxaD,6CAA8C,KAAK,CAAC;;;;;;;;oBAQtC,MAAM;;;;mBACN,MAAM"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;GAYG;AACH,yDAXW,YAAY,gBACZ,MAAM,gBACN,YAAY,eACZ,WAAW,wBACX,MAAM,oBACN,eAAe,GACd,eAAe,CAgE1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wDAdW,YAAY,qBACZ,MAAM,mBACN,MAAM,sBACN,MAAM,GAAC,IAAI,qBACX,MAAM,GAAC,IAAI,eACX,KAAK,CAAC,MAAM,CAAC,cACb,KAAK,CAAC,MAAM,CAAC,oBACb,KAAK,CAAC,MAAM,CAAC,oBACb,OAAO,oBAAoB,EAAE,SAAS,iBACtC,MAAM,0BACN,MAAM,GACL;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAgM1C;AAED;;;;;;;;;GASG;AACH,6DARW,YAAY,qBACZ,MAAM,eACN,KAAK,CAAC,MAAM,CAAC,cACb,KAAK,CAAC,MAAM,CAAC,wBACb,MAAM,GACL,MAAM,CA0CjB;AAED;;;;GAIG;AACH,qCAFY,SAAS,CAUpB;AAED;;;;;;GAMG;AACH,kCAJW,MAAM,UACN,KAAK,CAAC,MAAM,CAAC,GACZ,KAAK,CAAC,MAAM,CAAC,CAWxB;AAED;;;;;GAKG;AACH,qCAHW,KAAK,CAAC,MAAM,CAAC,GACZ,MAAM,CAWjB;AAED;;GAEG;AACH;;GAEG;AAEH;;;;;GAKG;AACH,0CAHW,OAAO,qBAAqB,EAAE,aAAa,GAAG,KAAK,CAAC,cAAc,CAAC,GAAG,cAAc,GACnF,KAAK,CAAC,cAAc,GAAG,WAAW,CAAC,CA2D9C;AAhfD,6CAA8C,KAAK,CAAC;6BA2avC,OAAO,0BAA0B,EAAE,SAAS;0BAG5C,OAAO,0BAA0B,EAAE,MAAM;;;;;;;;oBAtaxC,MAAM;;;;mBACN,MAAM"}

package/render/webgl/utils.js

@@ -430,3 +430,75 @@ export function colorDecodeId(color) {
   id += Math.round(color[3] * mult);
   return id;
 }
+
+/**
+ * @typedef {import('./VectorStyleRenderer.js').AsShaders} StyleAsShaders
+ */
+/**
+ * @typedef {import('./VectorStyleRenderer.js').AsRule} StyleAsRule
+ */
+
+/**
+ * Takes in either a Flat Style or an array of shaders (used as input for the webgl vector layer classes)
+ * and breaks it down into separate styles to be used by the VectorStyleRenderer class.
+ * @param {import('../../style/flat.js').FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders} style Flat style or shaders
+ * @return {Array<StyleAsShaders | StyleAsRule>} Separate styles as shaders or rules with a single flat style and a filter
+ */
+export function breakDownFlatStyle(style) {
+  // possible cases:
+  // - single shader
+  // - multiple shaders
+  // - single style
+  // - multiple styles
+  // - multiple rules
+  const asArray = Array.isArray(style) ? style : [style];
+
+  // if array of rules: break rules into separate styles, compute "else" filters
+  if ('style' in asArray[0]) {
+    /** @type {Array<StyleAsRule>} */
+    const styles = [];
+    const rules = /** @type {Array<import('../../style/flat.js').Rule>} */ (
+      asArray
+    );
+    const previousFilters = [];
+    for (const rule of rules) {
+      const ruleStyles = Array.isArray(rule.style) ? rule.style : [rule.style];
+      /** @type {import("../../expr/expression.js").EncodedExpression} */
+      let currentFilter = rule.filter;
+      if (rule.else && previousFilters.length) {
+        currentFilter = [
+          'all',
+          ...previousFilters.map((filter) => ['!', filter]),
+        ];
+        if (rule.filter) {
+          currentFilter.push(rule.filter);
+        }
+        if (currentFilter.length < 3) {
+          currentFilter = currentFilter[1];
+        }
+      }
+      if (rule.filter) {
+        previousFilters.push(rule.filter);
+      }
+      /** @type {Array<StyleAsRule>} */
+      const stylesWithFilters = ruleStyles.map((style) => ({
+        style,
+        ...(currentFilter && {filter: currentFilter}),
+      }));
+      styles.push(...stylesWithFilters);
+    }
+    return styles;
+  }
+
+  // if array of shaders: return as is
+  if ('builder' in asArray[0]) {
+    return /** @type {Array<StyleAsShaders>} */ (asArray);
+  }
+
+  return asArray.map(
+    (style) =>
+      /** @type {StyleAsRule} */ ({
+        style,
+      }),
+  );
+}

package/renderer/webgl/VectorLayer.d.ts

@@ -13,16 +13,17 @@ export const Uniforms: {
     HIT_DETECTION: string;
 };
 export default WebGLVectorLayerRenderer;
-export type VectorStyle = import("../../render/webgl/VectorStyleRenderer.js").VectorStyle;
+export type StyleAsShaders = import("../../render/webgl/VectorStyleRenderer.js").AsShaders;
+export type StyleAsRule = import("../../render/webgl/VectorStyleRenderer.js").AsRule;
 export type Options = {
     /**
      * A CSS class name to set to the canvas element.
      */
     className?: string | undefined;
     /**
-     * Vector style as literal style or shaders; can also accept an array of styles
+     * Flat vector style; also accepts shaders
      */
-    style: VectorStyle | Array<VectorStyle>;
+    style: import("../../style/flat.js").FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders;
     /**
      * Style variables
      */
@@ -40,12 +41,15 @@ export type Options = {
     postProcesses?: import("./Layer.js").PostProcessesOptions[] | undefined;
 };
 /**
- * @typedef {import('../../render/webgl/VectorStyleRenderer.js').VectorStyle} VectorStyle
+ * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsShaders} StyleAsShaders
+ */
+/**
+ * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsRule} StyleAsRule
  */
 /**
  * @typedef {Object} Options
  * @property {string} [className='ol-layer'] A CSS class name to set to the canvas element.
- * @property {VectorStyle|Array<VectorStyle>} style Vector style as literal style or shaders; can also accept an array of styles
+ * @property {import('../../style/flat.js').FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders} style Flat vector style; also accepts shaders
  * @property {Object<string, number|Array<number>|string|boolean>} variables Style variables
  * @property {boolean} [disableHitDetection=false] Setting this to true will provide a slight performance boost, but will
  * prevent all hit detection on the layer.
@@ -124,7 +128,7 @@ declare class WebGLVectorLayerRenderer extends WebGLLayerRenderer<any> {
      */
     private styleVariables_;
     /**
-     * @type {Array<VectorStyle>}
+     * @type {Array<StyleAsRule | StyleAsShaders>}
      * @private
      */
     private styles_;

package/renderer/webgl/VectorLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VectorLayer.d.ts","sourceRoot":"","sources":["VectorLayer.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;EAKE;;0BAGW,OAAO,2CAA2C,EAAE,WAAW;;;;;;;;;WAM9D,WAAW,GAAC,KAAK,CAAC,WAAW,CAAC;;;;;;;;;;;;;;;;;AAP5C;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,sBAAsB,EAAE,OAAO,WACtC,OAAO,EA0GjB;IA5FC;;;OAGG;IACH,6BAAwD;IAExD;;;OAGG;IACH,yBAAqB;IAErB;;OAEG;IACH,wBAAyB;IAEzB;;OAEG;IACH,wBAAoC;IAEpC;;;;;;OAMG;IACH,0BAA0C;IAE1C;;OAEG;IACH,mBAAwB;IACxB;;OAEG;IACH,sBAAsC;IACtC;;OAEG;IACH,iBAA4B;IAE5B;;;OAGG;IACH,oCAAoD;IAEpD;;;OAGG;IACH,wBAAyB;IAEzB;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,wBAAyB;IAEzB;;;OAGG;IACH,iBAAkB;IAIlB;;OAEG;IACH,eAAsC;IAEtC;;;OAGG;IACH,8BAAkC;IAElC;;;OAGG;IACH,0BAA6B;IAG/B;;;OAGG;IACH,4BAoCC;IAED;;;OAGG;IACH,sBAKC;IAED;;OAEG;IACH,yBAWC;IAED;;OAEG;IACH,mCAMC;IAoBD;;;;OAIG;IACH,kCAGC;IAED;;;OAGG;IACH,oCAGC;IAED;;;OAGG;IACH,mCAGC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,uBAsBC;IAED;;;;;OAKG;IACH,iCAJW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CA+BtB;IAwED;;;;;;;OAOG;IACH,yBANW,OAAO,cAAc,EAAE,UAAU,mBACjC,OAAO,cACP,MAAM,YACN,MAAM,cACN,MAAM,QAuChB;IA0CD;;;OAGG;IACH,wBAFW,OAAO,2CAA2C,EAAE,YAAY,QAkB1E;CAkBF;+BAjiB8B,YAAY"}
+{"version":3,"file":"VectorLayer.d.ts","sourceRoot":"","sources":["VectorLayer.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;EAKE;;6BAGW,OAAO,2CAA2C,EAAE,SAAS;0BAG7D,OAAO,2CAA2C,EAAE,MAAM;;;;;;;;;WAMzD,OAAO,qBAAqB,EAAE,aAAa,GAAG,KAAK,CAAC,cAAc,CAAC,GAAG,cAAc;;;;;;;;;;;;;;;;;AAVlG;;GAEG;AACH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,sBAAsB,EAAE,OAAO,WACtC,OAAO,EA0GjB;IA5FC;;;OAGG;IACH,6BAAwD;IAExD;;;OAGG;IACH,yBAAqB;IAErB;;OAEG;IACH,wBAAyB;IAEzB;;OAEG;IACH,wBAAoC;IAEpC;;;;;;OAMG;IACH,0BAA0C;IAE1C;;OAEG;IACH,mBAAwB;IACxB;;OAEG;IACH,sBAAsC;IACtC;;OAEG;IACH,iBAA4B;IAE5B;;;OAGG;IACH,oCAAoD;IAEpD;;;OAGG;IACH,wBAAyB;IAEzB;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,wBAAyB;IAEzB;;;OAGG;IACH,iBAAkB;IAIlB;;OAEG;IACH,eAAsC;IAEtC;;;OAGG;IACH,8BAAkC;IAElC;;;OAGG;IACH,0BAA6B;IAG/B;;;OAGG;IACH,4BAoCC;IAED;;;OAGG;IACH,sBAGC;IAED;;OAEG;IACH,yBAWC;IAED;;OAEG;IACH,mCAMC;IAoBD;;;;OAIG;IACH,kCAGC;IAED;;;OAGG;IACH,oCAGC;IAED;;;OAGG;IACH,mCAGC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,uBAsBC;IAED;;;;;OAKG;IACH,iCAJW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CA+BtB;IAwED;;;;;;;OAOG;IACH,yBANW,OAAO,cAAc,EAAE,UAAU,mBACjC,OAAO,cACP,MAAM,YACN,MAAM,cACN,MAAM,QAuChB;IA0CD;;;OAGG;IACH,wBAFW,OAAO,2CAA2C,EAAE,YAAY,QAkB1E;CAkBF;+BAliB8B,YAAY"}

package/renderer/webgl/VectorLayer.js

@@ -14,7 +14,7 @@ import {
 } from '../../proj.js';
 import MixedGeometryBatch from '../../render/webgl/MixedGeometryBatch.js';
 import VectorStyleRenderer from '../../render/webgl/VectorStyleRenderer.js';
-import {colorDecodeId} from '../../render/webgl/utils.js';
+import {breakDownFlatStyle, colorDecodeId} from '../../render/webgl/utils.js';
 import VectorEventType from '../../source/VectorEventType.js';
 import {
   apply as applyTransform,
@@ -41,13 +41,16 @@ export const Uniforms = {
 };
 
 /**
- * @typedef {import('../../render/webgl/VectorStyleRenderer.js').VectorStyle} VectorStyle
+ * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsShaders} StyleAsShaders
+ */
+/**
+ * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsRule} StyleAsRule
  */
 
 /**
  * @typedef {Object} Options
  * @property {string} [className='ol-layer'] A CSS class name to set to the canvas element.
- * @property {VectorStyle|Array<VectorStyle>} style Vector style as literal style or shaders; can also accept an array of styles
+ * @property {import('../../style/flat.js').FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders} style Flat vector style; also accepts shaders
  * @property {Object<string, number|Array<number>|string|boolean>} variables Style variables
  * @property {boolean} [disableHitDetection=false] Setting this to true will provide a slight performance boost, but will
  * prevent all hit detection on the layer.
@@ -146,7 +149,7 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
     this.styleVariables_ = {};
 
     /**
-     * @type {Array<VectorStyle>}
+     * @type {Array<StyleAsRule | StyleAsShaders>}
      * @private
      */
     this.styles_ = [];
@@ -231,9 +234,7 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
    */
   applyOptions_(options) {
     this.styleVariables_ = options.variables;
-    this.styles_ = Array.isArray(options.style)
-      ? options.style
-      : [options.style];
+    this.styles_ = breakDownFlatStyle(options.style);
   }
 
   /**

package/renderer/webgl/VectorTileLayer.d.ts

@@ -16,12 +16,13 @@ export namespace Attributes {
     let POSITION: string;
 }
 export default WebGLVectorTileLayerRenderer;
-export type VectorStyle = import("../../render/webgl/VectorStyleRenderer.js").VectorStyle;
+export type StyleAsShaders = import("../../render/webgl/VectorStyleRenderer.js").AsShaders;
+export type StyleAsRule = import("../../render/webgl/VectorStyleRenderer.js").AsRule;
 export type Options = {
     /**
-     * Vector style as literal style or shaders; can also accept an array of styles
+     * Flat vector style; also accepts shaders
      */
-    style: VectorStyle | Array<VectorStyle>;
+    style: import("../../style/flat.js").FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders;
     /**
      * Style variables. Each variable must hold a literal value (not
      * an expression). These variables can be used as {@link import ("../../expr/expression.js").ExpressionValue expressions} in the styles properties
@@ -42,11 +43,14 @@ export type Options = {
 };
 export type LayerType = import("../../layer/BaseTile.js").default<any, any>;
 /**
- * @typedef {import('../../render/webgl/VectorStyleRenderer.js').VectorStyle} VectorStyle
+ * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsShaders} StyleAsShaders
+ */
+/**
+ * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsRule} StyleAsRule
  */
 /**
  * @typedef {Object} Options
- * @property {VectorStyle|Array<VectorStyle>} style Vector style as literal style or shaders; can also accept an array of styles
+ * @property {import('../../style/flat.js').FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders} style Flat vector style; also accepts shaders
  * @property {import('../../style/flat.js').StyleVariables} [variables] Style variables. Each variable must hold a literal value (not
  * an expression). These variables can be used as {@link import("../../expr/expression.js").ExpressionValue expressions} in the styles properties
  * using the `['var', 'varName']` operator.
@@ -74,7 +78,7 @@ declare class WebGLVectorTileLayerRenderer extends WebGLBaseTileLayerRenderer<im
      */
     private hitDetectionEnabled_;
     /**
-     * @type {Array<VectorStyle>}
+     * @type {Array<StyleAsRule | StyleAsShaders>}
      * @private
      */
     private styles_;

package/renderer/webgl/VectorTileLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VectorTileLayer.d.ts","sourceRoot":"","sources":["VectorTileLayer.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;EAIE;;;;;0BAOW,OAAO,2CAA2C,EAAE,WAAW;;;;;WAK9D,WAAW,GAAC,KAAK,CAAC,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;AAN5C;;GAEG;AAEH;;;;;;;;;GASG;AAEH;;GAEG;AAEH;;;;GAIG;AACH;IACE;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EAuFjB;IA5EC;;;OAGG;IACH,6BAAwD;IAExD;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,wBAA8C;IAE9C;;;OAGG;IACH,wBAAyB;IAEzB;;;;;;OAMG;IACH,oCAAoD;IAEpD;;OAEG;IACH,sBAAsC;IACtC;;OAEG;IACH,iBAA4B;IAE5B;;;OAGG;IACH,wBAA2B;IAE3B;;OAEG;IACH,yBAGC;IAGD;;;OAGG;IACH,4BAMC;IAED;;;OAGG;IACH,yBAAqB;IAKvB;;;OAGG;IACH,wBAHW,OAAO,QAWjB;IAED;;;OAGG;IACH,sBAIC;IAED;;OAEG;IACH,yBA0CC;IAED;;OAEG;IACH,sBAYC;IAUD;;OAEG;IACH,8DAWC;IAED;;OAEG;IACH,uEAMC;IAED;;OAEG;IACH,yDA0BC;IAED;;OAEG;IACH,4FAeC;IAED;;;;;;;OAOG;IACH,uBAoBC;IAED;;OAEG;IACH,sNA4BC;IAED;;;OAGG;IACH,4BAFW,OAAO,cAAc,EAAE,UAAU,QAEd;CAS/B;uCA1XM,oBAAoB;yBALF,6BAA6B"}
+{"version":3,"file":"VectorTileLayer.d.ts","sourceRoot":"","sources":["VectorTileLayer.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;EAIE;;;;;6BAOW,OAAO,2CAA2C,EAAE,SAAS;0BAG7D,OAAO,2CAA2C,EAAE,MAAM;;;;;WAKzD,OAAO,qBAAqB,EAAE,aAAa,GAAG,KAAK,CAAC,cAAc,CAAC,GAAG,cAAc;;;;;;;;;;;;;;;;;;;;AATlG;;GAEG;AACH;;GAEG;AAEH;;;;;;;;;GASG;AAEH;;GAEG;AAEH;;;;GAIG;AACH;IACE;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EAuFjB;IA5EC;;;OAGG;IACH,6BAAwD;IAExD;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,wBAA8C;IAE9C;;;OAGG;IACH,wBAAyB;IAEzB;;;;;;OAMG;IACH,oCAAoD;IAEpD;;OAEG;IACH,sBAAsC;IACtC;;OAEG;IACH,iBAA4B;IAE5B;;;OAGG;IACH,wBAA2B;IAE3B;;OAEG;IACH,yBAGC;IAGD;;;OAGG;IACH,4BAMC;IAED;;;OAGG;IACH,yBAAqB;IAKvB;;;OAGG;IACH,wBAHW,OAAO,QAWjB;IAED;;;OAGG;IACH,sBAEC;IAED;;OAEG;IACH,yBAwCC;IAED;;OAEG;IACH,sBAYC;IAUD;;OAEG;IACH,8DAWC;IAED;;OAEG;IACH,uEAMC;IAED;;OAEG;IACH,yDA0BC;IAED;;OAEG;IACH,4FAeC;IAED;;;;;;;OAOG;IACH,uBAoBC;IAED;;OAEG;IACH,sNA4BC;IAED;;;OAGG;IACH,4BAFW,OAAO,cAAc,EAAE,UAAU,QAEd;CAS/B;uCAzXM,oBAAoB;yBALF,6BAA6B"}