ol 9.2.5-sh.1 → 10.0.0

package/render/webgl/VectorStyleRenderer.d.ts

@@ -87,7 +87,7 @@ export type StyleShaders = {
     builder: import("../../webgl/ShaderBuilder.js").ShaderBuilder;
     /**
      * Custom attributes made available in the vertex shaders.
-     * Default shaders rely on the attributes in {@link Attributes }.
+     * Default shaders rely on the attributes in {@link Attributes}.
      */
     attributes?: {
         [x: string]: AttributeDefinition;
@@ -99,7 +99,7 @@ export type StyleShaders = {
         [x: string]: import("../../webgl/Helper.js").UniformValue;
     } | undefined;
 };
-export type VectorStyle = import('../../style/webgl.js').WebGLStyle | StyleShaders;
+export type VectorStyle = import("../../style/webgl.js").WebGLStyle | StyleShaders;
 /**
  * @typedef {Object} AttributeDefinition A description of a custom attribute to be passed on to the GPU, with a value different
  * for each feature.
@@ -160,48 +160,74 @@ declare class VectorStyleRenderer {
      * @param {import('../../webgl/Helper.js').default} helper Helper
      * @param {boolean} enableHitDetection Whether to enable the hit detection (needs compatible shader)
      */
-    constructor(styleOrShaders: VectorStyle, helper: import('../../webgl/Helper.js').default, enableHitDetection: boolean);
-    helper_: import("../../webgl/Helper.js").default;
-    hitDetectionEnabled_: boolean;
+    constructor(styleOrShaders: VectorStyle, helper: import("../../webgl/Helper.js").default, enableHitDetection: boolean);
+    /**
+     * @private
+     */
+    private helper_;
+    /**
+     * @private
+     */
+    private hitDetectionEnabled_;
     /**
      * @type {boolean}
      * @private
      */
     private hasFill_;
-    fillVertexShader_: string | null | undefined;
-    fillFragmentShader_: string | null | undefined;
-    fillProgram_: WebGLProgram | undefined;
+    /**
+     * @private
+     */
+    private fillVertexShader_;
+    /**
+     * @private
+     */
+    private fillFragmentShader_;
+    /**
+     * @private
+     */
+    private fillProgram_;
     /**
      * @type {boolean}
      * @private
      */
     private hasStroke_;
-    strokeVertexShader_: string | null | undefined;
-    strokeFragmentShader_: string | null | undefined;
-    strokeProgram_: WebGLProgram | undefined;
+    /**
+     * @private
+     */
+    private strokeVertexShader_;
+    /**
+     * @private
+     */
+    private strokeFragmentShader_;
+    /**
+     * @private
+     */
+    private strokeProgram_;
     /**
      * @type {boolean}
      * @private
      */
     private hasSymbol_;
-    symbolVertexShader_: string | null | undefined;
-    symbolFragmentShader_: string | null | undefined;
-    symbolProgram_: WebGLProgram | undefined;
-    customAttributes_: ({
-        hitColor: {
-            callback(): number[];
-            size: number;
-        };
-    } & {
-        [x: string]: AttributeDefinition;
-    }) | ({
-        hitColor?: undefined;
-    } & {
-        [x: string]: AttributeDefinition;
-    });
-    uniforms_: {
-        [x: string]: import("../../webgl/Helper.js").UniformValue;
-    } | undefined;
+    /**
+     * @private
+     */
+    private symbolVertexShader_;
+    /**
+     * @private
+     */
+    private symbolFragmentShader_;
+    /**
+     * @private
+     */
+    private symbolProgram_;
+    /**
+     * @private
+     */
+    private customAttributes_;
+    /**
+     * @private
+     */
+    private uniforms_;
     /**
      * @type {Array<import('../../webgl/Helper.js').AttributeDescription>}
      * @private
@@ -222,7 +248,7 @@ declare class VectorStyleRenderer {
      * @param {import("../../transform.js").Transform} transform Transform to apply to coordinates
      * @return {Promise<WebGLBuffers>} A promise resolving to WebGL buffers
      */
-    generateBuffers(geometryBatch: import('./MixedGeometryBatch.js').default, transform: import("../../transform.js").Transform): Promise<WebGLBuffers>;
+    generateBuffers(geometryBatch: import("./MixedGeometryBatch.js").default, transform: import("../../transform.js").Transform): Promise<WebGLBuffers>;
     /**
      * @param {import('./MixedGeometryBatch.js').default} geometryBatch Geometry batch
      * @param {import("../../transform.js").Transform} transform Transform to apply to coordinates

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

@@ -1 +1 @@
-{"version":3,"file":"VectorStyleRenderer.d.ts","sourceRoot":"","sources":["VectorStyleRenderer.js"],"names":[],"mappings":";;;;yBA4BU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;qBAiBY,OAAO,yBAAyB,EAAE,iBAAiB,QAAE,OAAO,eAAe,EAAE,WAAW,KAAE,MAAM,GAAC,MAAM,MAAM,CAAC;;;QAKtH,MAAM,GAAE,mBAAmB;;;QAC3B,MAAM,GAAE,OAAO,oBAAoB,EAAE,YAAY;;;;;;oBAKvD,MAAM,gBAAgB,CAAC;;;;uBACvB,MAAM,gBAAgB,CAAC;;;;kBACvB,MAAM,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;;;;OAIG;IACH,4BAJW,WAAW,UACX,OAAO,uBAAuB,EAAE,OAAO,sBACvC,OAAO,EAyJjB;IAtJC,iDAAqB;IAErB,8BAA8C;IAgB9C;;;OAGG;IACH,iBAAuD;IAErD,6CAA8D;IAC9D,+CAAkE;IAClE,uCAGC;IAGH;;;OAGG;IACH,mBAA2D;IAEzD,+CAAkE;IAClE,iDAAsE;IACtE,yCAGC;IAGH;;;OAGG;IACH,mBAA2D;IAEzD,+CAAkE;IAClE,iDAAsE;IACtE,yCAGC;IAcH;;;;;;;;;;;OAIC;IACD;;kBAAiC;IASjC;;;OAGG;IACH,+BAOC;IACD;;;OAGG;IACH,kCA2BC;IACD;;;OAGG;IACH,6BAYC;IAOH;;;;OAIG;IACH,+BAJW,OAAO,yBAAyB,EAAE,OAAO,aACzC,OAAO,oBAAoB,EAAE,SAAS,GACrC,QAAQ,YAAY,CAAC,CAqChC;IAED;;;;;OAKG;IACH,oCA+BC;IAED;;;;;;OAMG;IACH,gCAuEC;IAED;;;;;OAKG;IACH,gBAJW,YAAY,cACZ,OAAO,cAAc,EAAE,UAAU,2BACrB,IAAI,QA8B1B;IAED;;;;;;;;OAQG;IACH,wBAkBC;CACF;6BAle4B,uBAAuB"}
+{"version":3,"file":"VectorStyleRenderer.d.ts","sourceRoot":"","sources":["VectorStyleRenderer.js"],"names":[],"mappings":";;;;yBA4BU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;cAiBF,CAAS,IAAwD,EAAnD,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,IAAmC,EAAnC,OAAO,eAAe,EAAE,WAAW,KAAE,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC;;mCAK7H;QAAO,MAAM,GAAE,mBAAmB;CAAC;iCACnC;QAAO,MAAM,GAAE,OAAO,oBAAoB,EAAE,YAAY;CAAC;;;;;oBAKxD,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;;;;OAIG;IACH,4BAJW,WAAW,UACX,OAAO,uBAAuB,EAAE,OAAO,sBACvC,OAAO,EAgMjB;IA7LC;;OAEG;IACH,gBAAqB;IAErB;;OAEG;IACH,6BAA8C;IAgB9C;;;OAGG;IACH,iBAAuD;IAErD;;OAEG;IACH,0BAA8D;IAC9D;;OAEG;IACH,4BAAkE;IAClE;;OAEG;IACH,qBAGC;IAGH;;;OAGG;IACH,mBAA2D;IAEzD;;OAEG;IACH,4BAAkE;IAClE;;OAEG;IACH,8BAAsE;IACtE;;OAEG;IACH,uBAGC;IAGH;;;OAGG;IACH,mBAA2D;IAEzD;;OAEG;IACH,4BAAkE;IAClE;;OAEG;IACH,8BAAsE;IACtE;;OAEG;IACH,uBAGC;IAcH;;OAEG;IACH,0BAIC;IACD;;OAEG;IACH,kBAAiC;IASjC;;;OAGG;IACH,+BAOC;IACD;;;OAGG;IACH,kCA2BC;IACD;;;OAGG;IACH,6BAYC;IAOH;;;;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,gCAuEC;IAED;;;;;OAKG;IACH,gBAJW,YAAY,cACZ,OAAO,cAAc,EAAE,UAAU,qBACjC,MAAY,IAAI,QA8B1B;IAED;;;;;;;;OAQG;IACH,wBAkBC;CACF;6BAzgB4B,uBAAuB"}

package/render/webgl/VectorStyleRenderer.js

@@ -106,8 +106,14 @@ class VectorStyleRenderer {
    * @param {boolean} enableHitDetection Whether to enable the hit detection (needs compatible shader)
    */
   constructor(styleOrShaders, helper, enableHitDetection) {
+    /**
+     * @private
+     */
     this.helper_ = helper;
 
+    /**
+     * @private
+     */
     this.hitDetectionEnabled_ = enableHitDetection;
     let shaders = /** @type {StyleShaders} */ (styleOrShaders);
     const isShaders = 'builder' in styleOrShaders;
@@ -130,8 +136,17 @@ class VectorStyleRenderer {
      */
     this.hasFill_ = !!shaders.builder.getFillVertexShader();
     if (this.hasFill_) {
+      /**
+       * @private
+       */
       this.fillVertexShader_ = shaders.builder.getFillVertexShader();
+      /**
+       * @private
+       */
       this.fillFragmentShader_ = shaders.builder.getFillFragmentShader();
+      /**
+       * @private
+       */
       this.fillProgram_ = this.helper_.getProgram(
         this.fillFragmentShader_,
         this.fillVertexShader_,
@@ -144,8 +159,17 @@ class VectorStyleRenderer {
      */
     this.hasStroke_ = !!shaders.builder.getStrokeVertexShader();
     if (this.hasStroke_) {
+      /**
+       * @private
+       */
       this.strokeVertexShader_ = shaders.builder.getStrokeVertexShader();
+      /**
+       * @private
+       */
       this.strokeFragmentShader_ = shaders.builder.getStrokeFragmentShader();
+      /**
+       * @private
+       */
       this.strokeProgram_ = this.helper_.getProgram(
         this.strokeFragmentShader_,
         this.strokeVertexShader_,
@@ -158,8 +182,17 @@ class VectorStyleRenderer {
      */
     this.hasSymbol_ = !!shaders.builder.getSymbolVertexShader();
     if (this.hasSymbol_) {
+      /**
+       * @private
+       */
       this.symbolVertexShader_ = shaders.builder.getSymbolVertexShader();
+      /**
+       * @private
+       */
       this.symbolFragmentShader_ = shaders.builder.getSymbolFragmentShader();
+      /**
+       * @private
+       */
       this.symbolProgram_ = this.helper_.getProgram(
         this.symbolFragmentShader_,
         this.symbolVertexShader_,
@@ -177,11 +210,17 @@ class VectorStyleRenderer {
         }
       : {};
 
+    /**
+     * @private
+     */
     this.customAttributes_ = Object.assign(
       {},
       hitDetectionAttributes,
       shaders.attributes,
     );
+    /**
+     * @private
+     */
     this.uniforms_ = shaders.uniforms;
 
     const customAttributesDesc = Object.entries(this.customAttributes_).map(

package/render/webgl/renderinstructions.d.ts

@@ -2,7 +2,7 @@
  * @param {import('./VectorStyleRenderer.js').AttributeDefinitions} customAttributes Custom attributes
  * @return {number} Cumulated size of all attributes
  */
-export function getCustomAttributesSize(customAttributes: import('./VectorStyleRenderer.js').AttributeDefinitions): number;
+export function getCustomAttributesSize(customAttributes: import("./VectorStyleRenderer.js").AttributeDefinitions): number;
 /**
  * Render instructions for lines are structured like so:
  * [ x0, y0, customAttr0, ... , xN, yN, customAttrN ]
@@ -12,7 +12,7 @@ export function getCustomAttributesSize(customAttributes: import('./VectorStyleR
  * @param {import("../../transform.js").Transform} transform Transform to apply to coordinates
  * @return {Float32Array} Generated render instructions
  */
-export function generatePointRenderInstructions(batch: import("./MixedGeometryBatch.js").PointGeometryBatch, renderInstructions: Float32Array, customAttributes: import('./VectorStyleRenderer.js').AttributeDefinitions, transform: import("../../transform.js").Transform): Float32Array;
+export function generatePointRenderInstructions(batch: import("./MixedGeometryBatch.js").PointGeometryBatch, renderInstructions: Float32Array, customAttributes: import("./VectorStyleRenderer.js").AttributeDefinitions, transform: import("../../transform.js").Transform): Float32Array;
 /**
  * Render instructions for lines are structured like so:
  * [ customAttr0, ... , customAttrN, numberOfVertices0, x0, y0, ... , xN, yN, numberOfVertices1, ... ]
@@ -22,7 +22,7 @@ export function generatePointRenderInstructions(batch: import("./MixedGeometryBa
  * @param {import("../../transform.js").Transform} transform Transform to apply to coordinates
  * @return {Float32Array} Generated render instructions
  */
-export function generateLineStringRenderInstructions(batch: import("./MixedGeometryBatch.js").LineStringGeometryBatch, renderInstructions: Float32Array, customAttributes: import('./VectorStyleRenderer.js').AttributeDefinitions, transform: import("../../transform.js").Transform): Float32Array;
+export function generateLineStringRenderInstructions(batch: import("./MixedGeometryBatch.js").LineStringGeometryBatch, renderInstructions: Float32Array, customAttributes: import("./VectorStyleRenderer.js").AttributeDefinitions, transform: import("../../transform.js").Transform): Float32Array;
 /**
  * Render instructions for polygons are structured like so:
  * [ customAttr0, ..., customAttrN, numberOfRings, numberOfVerticesInRing0, ..., numberOfVerticesInRingN, x0, y0, ..., xN, yN, numberOfRings,... ]
@@ -32,5 +32,5 @@ export function generateLineStringRenderInstructions(batch: import("./MixedGeome
  * @param {import("../../transform.js").Transform} transform Transform to apply to coordinates
  * @return {Float32Array} Generated render instructions
  */
-export function generatePolygonRenderInstructions(batch: import("./MixedGeometryBatch.js").PolygonGeometryBatch, renderInstructions: Float32Array, customAttributes: import('./VectorStyleRenderer.js').AttributeDefinitions, transform: import("../../transform.js").Transform): Float32Array;
+export function generatePolygonRenderInstructions(batch: import("./MixedGeometryBatch.js").PolygonGeometryBatch, renderInstructions: Float32Array, customAttributes: import("./VectorStyleRenderer.js").AttributeDefinitions, transform: import("../../transform.js").Transform): Float32Array;
 //# sourceMappingURL=renderinstructions.d.ts.map

package/render/webgl/utils.d.ts

@@ -46,7 +46,7 @@ export function writePointFeatureToBuffers(instructions: Float32Array, elementIn
  * @return {{length: number, angle: number}} Cumulated length with the newly processed segment (in world units), new sum of the join angle tangents
  * @private
  */
-export function writeLineSegmentToBuffers(instructions: Float32Array, segmentStartIndex: number, segmentEndIndex: number, beforeSegmentIndex: number | null, afterSegmentIndex: number | null, vertexArray: Array<number>, indexArray: Array<number>, customAttributes: Array<number>, toWorldTransform: import('../../transform.js').Transform, currentLength: number, currentAngleTangentSum: number): {
+export function writeLineSegmentToBuffers(instructions: Float32Array, segmentStartIndex: number, segmentEndIndex: number, beforeSegmentIndex: number | null, afterSegmentIndex: number | null, vertexArray: Array<number>, indexArray: Array<number>, customAttributes: Array<number>, toWorldTransform: import("../../transform.js").Transform, currentLength: number, currentAngleTangentSum: number): {
     length: number;
     angle: number;
 };

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,kDAEL,eAAe,CAgE1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wDAdW,YAAY,qBACZ,MAAM,mBACN,MAAM,sBACN,MAAM,GAAC,IAAI,qBACX,MAAM,GAAC,IAAI,eACX,MAAM,MAAM,CAAC,cACb,MAAM,MAAM,CAAC,oBACb,MAAM,MAAM,CAAC,oBACb,OAAO,oBAAoB,EAAE,SAAS,iBACtC,MAAM,0BACN,MAAM,GACL;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAqL1C;AAED;;;;;;;;;GASG;AACH,6DARW,YAAY,qBACZ,MAAM,eACN,MAAM,MAAM,CAAC,cACb,MAAM,MAAM,CAAC,wBACb,MAAM,GACL,MAAM,CA0CjB;AAED;;;;GAIG;AACH,qCAFY,SAAS,CAUpB;AAED;;;;;;GAMG;AACH,kCAJW,MAAM,iCAEL,MAAM,MAAM,CAAC,CAWxB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,MAAM,CAAC,GACZ,MAAM,CAWjB;AA7ZD,mDAAoD;;;;;;;;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,kDAEL,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,CAqL1C;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,iCAEL,KAAK,CAAC,MAAM,CAAC,CAWxB;AAED;;;;;GAKG;AACH,qCAHW,KAAK,CAAC,MAAM,CAAC,GACZ,MAAM,CAWjB;AA7ZD,mDAAoD;;;;;;;;oBAQtC,MAAM;;;;mBACN,MAAM"}

package/render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["render.js"],"names":[],"mappings":"AAcA;;;;;;;;;GASG;AAEH;;;;;;GAMG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,mCALW,wBAAwB,2CAEvB,uBAAuB,CAiBlC;AAED;;;;;GAKG;AACH,wCAJW,OAAO,mBAAmB,EAAE,OAAO,GAClC,uBAAuB,CAuClC;AAED;;;;;;;GAOG;AACH,sCANW,OAAO,mBAAmB,EAAE,OAAO,SACnC,OAAO,YAAY,EAAE,KAAK,GAEzB,OAAO,YAAY,EAAE,KAAK,CAKrC;;;;;aA5Ha,wBAAwB;;;;aACxB,OAAO,cAAc,EAAE,WAAW;;;;cAClC,OAAO,0BAA0B,EAAE,OAAO;;;;gBAC1C,MAAM;;;;;gBACN,MAAM;;;;cAEN,MAAM;;;;;;;mCAQE,OAAO,cAAc,EAAE,WAAW,QAAE,OAAO,cAAc,EAAE,WAAW,KAAE,MAAM;;;;;;;;;;;;;;;oCA3BhE,8BAA8B"}
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["render.js"],"names":[],"mappings":"AAcA;;;;;;;;;GASG;AAEH;;;;;;GAMG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,mCALW,wBAAwB,2CAEvB,uBAAuB,CAiBlC;AAED;;;;;GAKG;AACH,wCAJW,OAAO,mBAAmB,EAAE,OAAO,GAClC,uBAAuB,CAuClC;AAED;;;;;;;GAOG;AACH,sCANW,OAAO,mBAAmB,EAAE,OAAO,SACnC,OAAO,YAAY,EAAE,KAAK,GAEzB,OAAO,YAAY,EAAE,KAAK,CAKrC;;;;;aA5Ha,wBAAwB;;;;aACxB,OAAO,cAAc,EAAE,WAAW;;;;cAClC,OAAO,0BAA0B,EAAE,OAAO;;;;gBAC1C,MAAM;;;;;gBACN,MAAM;;;;cAEN,MAAM;;;;;;;4BAQP,CAAS,IAAkC,EAAlC,OAAO,cAAc,EAAE,WAAW,EAAE,IAAkC,EAAlC,OAAO,cAAc,EAAE,WAAW,KAAE,MAAM;;;;;;;;;;;;;;;oCA3BhE,8BAA8B"}

package/renderer/Composite.d.ts

@@ -6,9 +6,10 @@ export default CompositeMapRenderer;
  */
 declare class CompositeMapRenderer extends MapRenderer {
     /**
+     * @private
      * @type {import("../events.js").EventsKey}
      */
-    fontChangeListenerKey_: import("../events.js").EventsKey;
+    private fontChangeListenerKey_;
     /**
      * @private
      * @type {HTMLDivElement}
@@ -28,7 +29,7 @@ declare class CompositeMapRenderer extends MapRenderer {
      * @param {import("../Map.js").FrameState} frameState Frame state.
      * @param {Array<import('../layer/Layer.js').State>} layerStates Layers.
      */
-    declutter(frameState: import("../Map.js").FrameState, layerStates: Array<import('../layer/Layer.js').State>): void;
+    declutter(frameState: import("../Map.js").FrameState, layerStates: Array<import("../layer/Layer.js").State>): void;
 }
 import MapRenderer from './Map.js';
 //# sourceMappingURL=Composite.d.ts.map

package/renderer/Composite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Composite.d.ts","sourceRoot":"","sources":["Composite.js"],"names":[],"mappings":";AAcA;;;;GAIG;AACH;IAOI;;OAEG;IACH,wBAFU,OAAO,cAAc,EAAE,SAAS,CAMzC;IAED;;;OAGG;IACH,iBAA6C;IAY7C;;;OAGG;IACH,kBAAmB;IAEnB;;;OAGG;IACH,yBAA4B;IA+F9B;;;OAGG;IACH,sBAHW,OAAO,WAAW,EAAE,UAAU,eAC9B,MAAM,OAAO,mBAAmB,EAAE,KAAK,CAAC,QAgBlD;CACF;wBA3KuB,UAAU"}
+{"version":3,"file":"Composite.d.ts","sourceRoot":"","sources":["Composite.js"],"names":[],"mappings":";AAcA;;;;GAIG;AACH;IAOI;;;OAGG;IACH,+BAIC;IAED;;;OAGG;IACH,iBAA6C;IAY7C;;;OAGG;IACH,kBAAmB;IAEnB;;;OAGG;IACH,yBAA4B;IAoG9B;;;OAGG;IACH,sBAHW,OAAO,WAAW,EAAE,UAAU,eAC9B,KAAK,CAAC,OAAO,mBAAmB,EAAE,KAAK,CAAC,QAgBlD;CACF;wBAjLuB,UAAU"}

package/renderer/Composite.js

@@ -25,6 +25,7 @@ class CompositeMapRenderer extends MapRenderer {
     super(map);
 
     /**
+     * @private
      * @type {import("../events.js").EventsKey}
      */
     this.fontChangeListenerKey_ = listen(
@@ -65,6 +66,7 @@ class CompositeMapRenderer extends MapRenderer {
   /**
    * @param {import("../render/EventType.js").default} type Event type.
    * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @override
    */
   dispatchRenderEvent(type, frameState) {
     const map = this.getMap();
@@ -74,15 +76,19 @@ class CompositeMapRenderer extends MapRenderer {
     }
   }
 
+  /**
+   * @override
+   */
   disposeInternal() {
     unlistenByKey(this.fontChangeListenerKey_);
-    this.element_.parentNode.removeChild(this.element_);
+    this.element_.remove();
     super.disposeInternal();
   }
 
   /**
    * Render.
    * @param {?import("../Map.js").FrameState} frameState Frame state.
+   * @override
    */
   renderFrame(frameState) {
     if (!frameState) {
@@ -96,9 +102,9 @@ class CompositeMapRenderer extends MapRenderer {
     this.calculateMatrices2D(frameState);
     this.dispatchRenderEvent(RenderEventType.PRECOMPOSE, frameState);
 
-    const layerStatesArray = frameState.layerStatesArray.sort(function (a, b) {
-      return a.zIndex - b.zIndex;
-    });
+    const layerStatesArray = frameState.layerStatesArray.sort(
+      (a, b) => a.zIndex - b.zIndex,
+    );
     const declutter = layerStatesArray.some(
       (layerState) =>
         layerState.layer instanceof BaseVectorLayer &&

package/renderer/Layer.d.ts

@@ -2,7 +2,7 @@ export default LayerRenderer;
 /**
  * @template {import("../layer/Layer.js").default} LayerType
  */
-declare class LayerRenderer<LayerType extends import("../layer/Layer.js").default<import("../source.js").Source, LayerRenderer<any>>> extends Observable {
+declare class LayerRenderer<LayerType extends import("../layer/Layer.js").default> extends Observable {
     /**
      * @param {LayerType} layer Layer.
      */
@@ -15,10 +15,28 @@ declare class LayerRenderer<LayerType extends import("../layer/Layer.js").defaul
     /** @private */
     private boundHandleImageChange_;
     /**
-     * @protected
+     * @private
      * @type {LayerType}
      */
-    protected layer_: LayerType;
+    private layer_;
+    /**
+     * @type {Array<string>}
+     * @private
+     */
+    private staleKeys_;
+    /**
+     * @type {number}
+     * @protected
+     */
+    protected maxStaleKeys: number;
+    /**
+     * @return {Array<string>} Get the list of stale keys.
+     */
+    getStaleKeys(): Array<string>;
+    /**
+     * @param {string} key The new stale key.
+     */
+    prependStaleKey(key: string): void;
     /**
      * Asynchronous layer level hit detection.
      * @param {import("../pixel.js").Pixel} pixel Pixel.
@@ -46,31 +64,6 @@ declare class LayerRenderer<LayerType extends import("../layer/Layer.js").defaul
      * @return {HTMLElement|null} The rendered element.
      */
     renderFrame(frameState: import("../Map.js").FrameState, target: HTMLElement | null): HTMLElement | null;
-    /**
-     * @param {Object<number, Object<string, import("../Tile.js").default>>} tiles Lookup of loaded tiles by zoom level.
-     * @param {number} zoom Zoom level.
-     * @param {import("../Tile.js").default} tile Tile.
-     * @return {boolean|void} If `false`, the tile will not be considered loaded.
-     */
-    loadedTileCallback(tiles: {
-        [x: number]: {
-            [x: string]: import("../Tile.js").default;
-        };
-    }, zoom: number, tile: import("../Tile.js").default): boolean | void;
-    /**
-     * Create a function that adds loaded tiles to the tile lookup.
-     * @param {import("../source/Tile.js").default} source Tile source.
-     * @param {import("../proj/Projection.js").default} projection Projection of the tiles.
-     * @param {Object<number, Object<string, import("../Tile.js").default>>} tiles Lookup of loaded tiles by zoom level.
-     * @return {function(number, import("../TileRange.js").default):boolean} A function that can be
-     *     called with a zoom level and a tile range to add loaded tiles to the lookup.
-     * @protected
-     */
-    protected createLoadedTileFinder(source: import("../source/Tile.js").default, projection: import("../proj/Projection.js").default, tiles: {
-        [x: number]: {
-            [x: string]: import("../Tile.js").default;
-        };
-    }): (arg0: number, arg1: import("../TileRange.js").default) => boolean;
     /**
      * @abstract
      * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
@@ -81,7 +74,7 @@ declare class LayerRenderer<LayerType extends import("../layer/Layer.js").defaul
      * @return {T|undefined} Callback result.
      * @template T
      */
-    forEachFeatureAtCoordinate<T>(coordinate: import("../coordinate.js").Coordinate, frameState: import("../Map.js").FrameState, hitTolerance: number, callback: import("./vector.js").FeatureCallback<T>, matches: import("./Map.js").HitMatch<T>[]): T | undefined;
+    forEachFeatureAtCoordinate<T>(coordinate: import("../coordinate.js").Coordinate, frameState: import("../Map.js").FrameState, hitTolerance: number, callback: import("./vector.js").FeatureCallback<T>, matches: Array<import("./Map.js").HitMatch<T>>): T | undefined;
     /**
      * @return {LayerType} Layer.
      */

package/renderer/Layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Layer.d.ts","sourceRoot":"","sources":["Layer.js"],"names":[],"mappings":";AAQA;;GAEG;AACH;IACE;;OAEG;IACH,mBAFW,SAAS,EAmBnB;IAdC;;;OAGG;IACH,OAFU,OAAO,CAEA;IAEjB,eAAe;IACf,gCAAiE;IAEjE;;;OAGG;IACH,kBAFU,SAAS,CAEA;IAGrB;;;;;OAKG;IACH,mBAJW,OAAO,aAAa,EAAE,KAAK,GAC1B,QAAQ,MAAM,OAAO,YAAY,EAAE,WAAW,CAAC,CAAC,CAK3D;IAED;;;OAGG;IACH,eAHW,OAAO,aAAa,EAAE,KAAK,GAC1B,iBAAiB,GAAC,UAAU,GAAC,YAAY,GAAC,QAAQ,GAAC,IAAI,CAIlE;IAED;;;;;OAKG;IACH,yBAHW,OAAO,WAAW,EAAE,UAAU,GAC7B,OAAO,CAIlB;IAED;;;;;;OAMG;IACH,wBAJW,OAAO,WAAW,EAAE,UAAU,UAC9B,WAAW,GAAC,IAAI,GACf,WAAW,GAAC,IAAI,CAI3B;IAED;;;;;OAKG;IACH;YALkB,MAAM;gBAAS,MAAM,GAAE,OAAO,YAAY,EAAE,OAAO;;aAC1D,MAAM,QACN,OAAO,YAAY,EAAE,OAAO,GAC3B,OAAO,GAAC,IAAI,CAQvB;IAED;;;;;;;;OAQG;IACH,yCAPW,OAAO,mBAAmB,EAAE,OAAO,cACnC,OAAO,uBAAuB,EAAE,OAAO;YAChC,MAAM;gBAAS,MAAM,GAAE,OAAO,YAAY,EAAE,OAAO;;eAChD,MAAM,QAAE,OAAO,iBAAiB,EAAE,OAAO,KAAE,OAAO,CAgBtE;IACD;;;;;;;;;OASG;IACH,0CARW,OAAO,kBAAkB,EAAE,UAAU,cACrC,OAAO,WAAW,EAAE,UAAU,gBAC9B,MAAM,gHAchB;IAED;;OAEG;IACH,YAFY,SAAS,CAIpB;IAED;;;OAGG;IACH,2BAAuB;IAEvB;;;;OAIG;IACH,2BAQC;IAED;;;;;;OAMG;IACH,2BAJW,OAAO,aAAa,EAAE,OAAO,GAC5B,OAAO,CAalB;IAED;;OAEG;IACH,0CAKC;IAED;;OAEG;IACH,2BAFW,OAAO,WAAW,EAAE,UAAU,QAEZ;CAS9B;uBAjMsB,kBAAkB"}
+{"version":3,"file":"Layer.d.ts","sourceRoot":"","sources":["Layer.js"],"names":[],"mappings":";AAUA;;GAEG;AACH,4BAFmD,SAAS,SAA/C,OAAQ,mBAAmB,EAAE,OAAQ;IAGhD;;OAEG;IACH,mBAFW,SAAS,EA+BnB;IA1BC;;;OAGG;IACH,OAFU,OAAO,CAEA;IAEjB,eAAe;IACf,gCAAiE;IAEjE;;;OAGG;IACH,eAAmB;IAEnB;;;OAGG;IACH,mBAA6B;IAE7B;;;OAGG;IACH,wBAHU,MAAM,CAGgB;IAGlC;;OAEG;IACH,gBAFY,KAAK,CAAC,MAAM,CAAC,CAIxB;IAED;;OAEG;IACH,qBAFW,MAAM,QAOhB;IAED;;;;;OAKG;IACH,mBAJW,OAAO,aAAa,EAAE,KAAK,GAC1B,OAAO,CAAC,KAAK,CAAC,OAAO,YAAY,EAAE,WAAW,CAAC,CAAC,CAK3D;IAED;;;OAGG;IACH,eAHW,OAAO,aAAa,EAAE,KAAK,GAC1B,iBAAiB,GAAC,UAAU,GAAC,YAAY,GAAC,QAAQ,GAAC,IAAI,CAIlE;IAED;;;;;OAKG;IACH,yBAHW,OAAO,WAAW,EAAE,UAAU,GAC7B,OAAO,CAIlB;IAED;;;;;;OAMG;IACH,wBAJW,OAAO,WAAW,EAAE,UAAU,UAC9B,WAAW,GAAC,IAAI,GACf,WAAW,GAAC,IAAI,CAI3B;IAED;;;;;;;;;OASG;IACH,2BAFa,CAAC,cANH,OAAO,kBAAkB,EAAE,UAAU,cACrC,OAAO,WAAW,EAAE,UAAU,gBAC9B,MAAM,YACN,OAAO,aAAa,EAAE,eAAe,CAAC,CAAC,CAAC,WACxC,KAAK,CAAC,OAAO,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,GACpC,CAAC,GAAC,SAAS,CAWtB;IAED;;OAEG;IACH,YAFY,SAAS,CAIpB;IAED;;;OAGG;IACH,2BAAuB;IAEvB;;;;OAIG;IACH,2BAQC;IAED;;;;;;OAMG;IACH,2BAJW,OAAO,aAAa,EAAE,OAAO,GAC5B,OAAO,CAalB;IAED;;OAEG;IACH,0CAKC;IAED;;OAEG;IACH,2BAFW,OAAO,WAAW,EAAE,UAAU,QAEZ;CAU9B;uBA7LsB,kBAAkB"}

package/renderer/Layer.js

@@ -6,6 +6,8 @@ import ImageState from '../ImageState.js';
 import Observable from '../Observable.js';
 import {abstract} from '../util.js';
 
+const maxStaleKeys = 5;
+
 /**
  * @template {import("../layer/Layer.js").default} LayerType
  */
@@ -26,10 +28,39 @@ class LayerRenderer extends Observable {
     this.boundHandleImageChange_ = this.handleImageChange_.bind(this);
 
     /**
-     * @protected
+     * @private
      * @type {LayerType}
      */
     this.layer_ = layer;
+
+    /**
+     * @type {Array<string>}
+     * @private
+     */
+    this.staleKeys_ = new Array();
+
+    /**
+     * @type {number}
+     * @protected
+     */
+    this.maxStaleKeys = maxStaleKeys;
+  }
+
+  /**
+   * @return {Array<string>} Get the list of stale keys.
+   */
+  getStaleKeys() {
+    return this.staleKeys_;
+  }
+
+  /**
+   * @param {string} key The new stale key.
+   */
+  prependStaleKey(key) {
+    this.staleKeys_.unshift(key);
+    if (this.staleKeys_.length > this.maxStaleKeys) {
+      this.staleKeys_.length = this.maxStaleKeys;
+    }
   }
 
   /**
@@ -71,42 +102,6 @@ class LayerRenderer extends Observable {
     return abstract();
   }
 
-  /**
-   * @param {Object<number, Object<string, import("../Tile.js").default>>} tiles Lookup of loaded tiles by zoom level.
-   * @param {number} zoom Zoom level.
-   * @param {import("../Tile.js").default} tile Tile.
-   * @return {boolean|void} If `false`, the tile will not be considered loaded.
-   */
-  loadedTileCallback(tiles, zoom, tile) {
-    if (!tiles[zoom]) {
-      tiles[zoom] = {};
-    }
-    tiles[zoom][tile.tileCoord.toString()] = tile;
-    return undefined;
-  }
-
-  /**
-   * Create a function that adds loaded tiles to the tile lookup.
-   * @param {import("../source/Tile.js").default} source Tile source.
-   * @param {import("../proj/Projection.js").default} projection Projection of the tiles.
-   * @param {Object<number, Object<string, import("../Tile.js").default>>} tiles Lookup of loaded tiles by zoom level.
-   * @return {function(number, import("../TileRange.js").default):boolean} A function that can be
-   *     called with a zoom level and a tile range to add loaded tiles to the lookup.
-   * @protected
-   */
-  createLoadedTileFinder(source, projection, tiles) {
-    return (
-      /**
-       * @param {number} zoom Zoom level.
-       * @param {import("../TileRange.js").default} tileRange Tile range.
-       * @return {boolean} The tile range is fully loaded.
-       */
-      (zoom, tileRange) => {
-        const callback = this.loadedTileCallback.bind(this, tiles, zoom);
-        return source.forEachLoadedTile(projection, zoom, tileRange, callback);
-      }
-    );
-  }
   /**
    * @abstract
    * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
@@ -191,6 +186,7 @@ class LayerRenderer extends Observable {
 
   /**
    * Clean up.
+   * @override
    */
   disposeInternal() {
     delete this.layer_;

package/renderer/Map.d.ts

@@ -83,7 +83,7 @@ declare class MapRenderer extends Disposable {
      * @return {boolean} Is there a feature at the given coordinate?
      * @template U
      */
-    hasFeatureAtCoordinate<U_1>(coordinate: import("../coordinate.js").Coordinate, frameState: import("../Map.js").FrameState, hitTolerance: number, checkWrapped: boolean, layerFilter: (this: U_1, arg1: import("../layer/Layer.js").default) => boolean, thisArg: U_1): boolean;
+    hasFeatureAtCoordinate<U>(coordinate: import("../coordinate.js").Coordinate, frameState: import("../Map.js").FrameState, hitTolerance: number, checkWrapped: boolean, layerFilter: (this: U, arg1: import("../layer/Layer.js").default) => boolean, thisArg: U): boolean;
     /**
      * @return {import("../Map.js").default} Map.
      */

package/renderer/Map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Map.d.ts","sourceRoot":"","sources":["Map.js"],"names":[],"mappings":";;;;;aAec,OAAO,eAAe,EAAE,WAAW;;;;WACnC,OAAO,mBAAmB,EAAE,OAAO;;;;cACnC,OAAO,2BAA2B,EAAE,OAAO;;;;gBAC3C,MAAM;;;;cACN,OAAO,aAAa,EAAE,eAAe,CAAC,CAAC,CAAC;;AAPtD;;;;;;;;GAQG;AAEH;;GAEG;AACH;IACE;;OAEG;IACH,iBAFW,OAAO,WAAW,EAAE,OAAO,EAUrC;IALC;;;OAGG;IACH,aAAe;IAGjB;;;;OAIG;IACH,2CAFW,OAAO,WAAW,EAAE,UAAU,QAIxC;IAED;;;OAGG;IACH,0CAHW,OAAO,WAAW,EAAE,UAAU,QAoBxC;IAED;;;;;;;;;;;;;;OAcG;IACH,gDAdW,OAAO,kBAAkB,EAAE,UAAU,cACrC,OAAO,WAAW,EAAE,UAAU,gBAC9B,MAAM,gBACN,OAAO,+FAGW,OAAO,mBAAmB,EAAE,OAAO,KAAG,OAAO,8BA4FzE;IAED;;;;;;;;;;;;OAYG;IACH,wCAZW,OAAO,kBAAkB,EAAE,UAAU,cACrC,OAAO,WAAW,EAAE,UAAU,gBAC9B,MAAM,gBACN,OAAO,iCACW,OAAO,mBAAmB,EAAE,OAAO,KAAG,OAAO,iBAK9D,OAAO,CAuBlB;IAED;;OAEG;IACH,UAFY,OAAO,WAAW,EAAE,OAAO,CAItC;IAED;;;;OAIG;IACH,wBAFY,OAAO,WAAW,EAAE,UAAU,eAIzC;IAED;;;OAGG;IACH,8CAHW,OAAO,WAAW,EAAE,UAAU,QAOxC;CACF;uBArOsB,kBAAkB"}
+{"version":3,"file":"Map.d.ts","sourceRoot":"","sources":["Map.js"],"names":[],"mappings":";qBAaa,CAAC;;;;aAEA,OAAO,eAAe,EAAE,WAAW;;;;WACnC,OAAO,mBAAmB,EAAE,OAAO;;;;cACnC,OAAO,2BAA2B,EAAE,OAAO;;;;gBAC3C,MAAM;;;;cACN,OAAO,aAAa,EAAE,eAAe,CAAC,CAAC,CAAC;;AAPtD;;;;;;;;GAQG;AAEH;;GAEG;AACH;IACE;;OAEG;IACH,iBAFW,OAAO,WAAW,EAAE,OAAO,EAUrC;IALC;;;OAGG;IACH,aAAe;IAGjB;;;;OAIG;IACH,0BAHW,GAAwC,cACxC,OAAO,WAAW,EAAE,UAAU,QAIxC;IAED;;;OAGG;IACH,0CAHW,OAAO,WAAW,EAAE,UAAU,QAoBxC;IAED;;;;;;;;;;;;;;OAcG;IACH,2BAFa,CAAC,EAAC,CAAC,EAAC,CAAC,cAZP,OAAO,kBAAkB,EAAE,UAAU,cACrC,OAAO,WAAW,EAAE,UAAU,gBAC9B,MAAM,gBACN,OAAO,YACP,OAAO,aAAa,EAAE,eAAe,CAAC,CAAC,CAAC,WACxC,CAAC,eACD,CAAS,IAAO,EAAD,CAAC,EAAE,IAAmC,EAAnC,OAAO,mBAAmB,EAAE,OAAO,KAAG,OAAO,YAI/D,CAAC,GACA,CAAC,GAAC,SAAS,CAuFtB;IAED;;;;;;;;;;;;OAYG;IACH,uBAFa,CAAC,cAVH,OAAO,kBAAkB,EAAE,UAAU,cACrC,OAAO,WAAW,EAAE,UAAU,gBAC9B,MAAM,gBACN,OAAO,eACP,CAAS,IAAO,EAAD,CAAC,EAAE,IAAmC,EAAnC,OAAO,mBAAmB,EAAE,OAAO,KAAG,OAAO,WAI/D,CAAC,GACA,OAAO,CAuBlB;IAED;;OAEG;IACH,UAFY,OAAO,WAAW,EAAE,OAAO,CAItC;IAED;;;;OAIG;IACH,wBAFY,OAAO,WAAW,EAAE,UAAU,OAAA,QAIzC;IAED;;;OAGG;IACH,8CAHW,OAAO,WAAW,EAAE,UAAU,QAOxC;CACF;uBArOsB,kBAAkB"}

package/renderer/canvas/ImageLayer.d.ts

@@ -13,23 +13,25 @@ declare class CanvasImageLayerRenderer extends CanvasLayerRenderer<any> {
      * @protected
      * @type {?import("../../Image.js").default}
      */
-    protected image_: import("../../Image.js").default | null;
+    protected image: import("../../Image.js").default | null;
     /**
      * @return {import('../../DataTile.js').ImageLike} Image.
      */
-    getImage(): import('../../DataTile.js').ImageLike;
+    getImage(): import("../../DataTile.js").ImageLike;
     /**
      * @param {import("../../pixel.js").Pixel} pixel Pixel.
      * @return {Uint8ClampedArray} Data at the pixel location.
+     * @override
      */
-    getData(pixel: import("../../pixel.js").Pixel): Uint8ClampedArray;
+    override getData(pixel: import("../../pixel.js").Pixel): Uint8ClampedArray;
     /**
      * Render the layer.
      * @param {import("../../Map.js").FrameState} frameState Frame state.
      * @param {HTMLElement} target Target that may be used to render content to.
      * @return {HTMLElement} The rendered element.
+     * @override
      */
-    renderFrame(frameState: import("../../Map.js").FrameState, target: HTMLElement): HTMLElement;
+    override renderFrame(frameState: import("../../Map.js").FrameState, target: HTMLElement): HTMLElement;
 }
 import CanvasLayerRenderer from './Layer.js';
 //# sourceMappingURL=ImageLayer.d.ts.map

package/renderer/canvas/ImageLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageLayer.d.ts","sourceRoot":"","sources":["ImageLayer.js"],"names":[],"mappings":";AAqBA;;;;GAIG;AACH;IACE;;OAEG;IACH,qEAQC;IALC;;;OAGG;IACH,kBAFW,OAAO,gBAAgB,EAAE,OAAO,QAEzB;IAGpB;;OAEG;IACH,YAFY,OAAO,mBAAmB,EAAE,SAAS,CAIhD;IAqDD;;;OAGG;IACH,eAHW,OAAO,gBAAgB,EAAE,KAAK,GAC7B,iBAAiB,CAyC5B;IAED;;;;;OAKG;IACH,wBAJW,OAAO,cAAc,EAAE,UAAU,UACjC,WAAW,GACV,WAAW,CAuFtB;CACF;gCAxO+B,YAAY"}
+{"version":3,"file":"ImageLayer.d.ts","sourceRoot":"","sources":["ImageLayer.js"],"names":[],"mappings":";AAqBA;;;;GAIG;AACH;IACE;;OAEG;IACH,wBAFW,2CAAsC,EAUhD;IALC;;;OAGG;IACH,iBAFW,OAAO,gBAAgB,EAAE,OAAO,OAAA,CAE1B;IAGnB;;OAEG;IACH,YAFY,OAAO,mBAAmB,EAAE,SAAS,CAIhD;IAsDD;;;;OAIG;IACH,wBAJW,OAAO,gBAAgB,EAAE,KAAK,GAC7B,iBAAiB,CA0C5B;IAED;;;;;;OAMG;IACH,iCALW,OAAO,cAAc,EAAE,UAAU,UACjC,WAAW,GACV,WAAW,CAwFtB;CACF;gCA3O+B,YAAY"}