ol 7.0.0-dev.1659450350443 → 7.0.0-dev.1659546714907

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ol",
-  "version": "7.0.0-dev.1659450350443",
+  "version": "7.0.0-dev.1659546714907",
   "description": "OpenLayers mapping library",
   "keywords": [
     "map",

package/source/BingMaps.d.ts

@@ -25,10 +25,6 @@ export type Options = {
      * Type of imagery.
      */
     imagerySet: string;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -152,7 +148,6 @@ export type CoverageArea = {
  * @property {string} [culture='en-us'] Culture code.
  * @property {string} key Bing Maps API key. Get yours at https://www.bingmapsportal.com/.
  * @property {string} imagerySet Type of imagery.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {number} [maxZoom=21] Max zoom. Default is what's advertized by the BingMaps service.

package/source/BingMaps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BingMaps.d.ts","sourceRoot":"","sources":["BingMaps.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH,mCAHW,OAAO,iBAAiB,EAAE,SAAS,GAClC,MAAM,CAoBjB;;;;;;;;;;;;;;;;;;SAkBa,MAAM;;;;gBACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAuBN,MAAM;;;;uBACN,MAAM;;;;8BACN,MAAM;;;;kBACN,MAAM,WAAW,CAAC;;;;;;eAKlB,MAAM,QAAQ,CAAC;;;;;;iBAKf,MAAM;;;;gBACN,MAAM;;;;aACN,MAAM;;;;aACN,MAAM;;;;cACN,MAAM;;;;wBACN,MAAM,MAAM,CAAC;;;;;;;;;;mBAMb,MAAM,YAAY,CAAC;;;;;;;;;;aAMnB,MAAM;;;;aACN,MAAM;;;;UACN,MAAM,MAAM,CAAC;;AA7D3B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;GAMG;AAEH;;;GAGG;AAEH;;;;;;;;;GASG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAsEjB;IA5CC;;;OAGG;IACH,eAAmB;IAEnB;;;OAGG;IACH,iBAAyE;IAEzE;;;OAGG;IACH,iBAAoE;IAEpE;;;OAGG;IACH,gBAA0B;IAE1B;;;OAGG;IACH,oBAAqC;IAkBvC;;;;;OAKG;IACH,aAHY,MAAM,CAKjB;IAED;;;;;OAKG;IACH,iBAHY,MAAM,CAKjB;IAED;;OAEG;IACH,wCAFW,+BAA+B,QAwHzC;CACF"}
+{"version":3,"file":"BingMaps.d.ts","sourceRoot":"","sources":["BingMaps.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH,mCAHW,OAAO,iBAAiB,EAAE,SAAS,GAClC,MAAM,CAoBjB;;;;;;;;;;;;;;;;;;SAkBa,MAAM;;;;gBACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAsBN,MAAM;;;;uBACN,MAAM;;;;8BACN,MAAM;;;;kBACN,MAAM,WAAW,CAAC;;;;;;eAKlB,MAAM,QAAQ,CAAC;;;;;;iBAKf,MAAM;;;;gBACN,MAAM;;;;aACN,MAAM;;;;aACN,MAAM;;;;cACN,MAAM;;;;wBACN,MAAM,MAAM,CAAC;;;;;;;;;;mBAMb,MAAM,YAAY,CAAC;;;;;;;;;;aAMnB,MAAM;;;;aACN,MAAM;;;;UACN,MAAM,MAAM,CAAC;;AA5D3B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;GAMG;AAEH;;;GAGG;AAEH;;;;;;;;;GASG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAgEjB;IA5CC;;;OAGG;IACH,eAAmB;IAEnB;;;OAGG;IACH,iBAAyE;IAEzE;;;OAGG;IACH,iBAAoE;IAEpE;;;OAGG;IACH,gBAA0B;IAE1B;;;OAGG;IACH,oBAAqC;IAkBvC;;;;;OAKG;IACH,aAHY,MAAM,CAKjB;IAED;;;;;OAKG;IACH,iBAHY,MAAM,CAKjB;IAED;;OAEG;IACH,wCAFW,+BAA+B,QAwHzC;CACF"}

package/source/BingMaps.js

@@ -52,7 +52,6 @@ const TOS_ATTRIBUTION =
  * @property {string} [culture='en-us'] Culture code.
  * @property {string} key Bing Maps API key. Get yours at https://www.bingmapsportal.com/.
  * @property {string} imagerySet Type of imagery.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {number} [maxZoom=21] Max zoom. Default is what's advertized by the BingMaps service.
@@ -121,16 +120,10 @@ class BingMaps extends TileImage {
   constructor(options) {
     const hidpi = options.hidpi !== undefined ? options.hidpi : false;
 
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     super({
       cacheSize: options.cacheSize,
       crossOrigin: 'anonymous',
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       opaque: true,
       projection: getProjection('EPSG:3857'),
       reprojectionErrorThreshold: options.reprojectionErrorThreshold,

package/source/DataTile.d.ts

@@ -57,11 +57,6 @@ export type Options = {
      * The source state.
      */
     state?: import("./Source.js").State | undefined;
-    /**
-     * Deprecated.  To have tiles scaled, pass a `tileSize` representing
-     * the source tile size and a `tileGrid` with the desired rendered tile size.
-     */
-    tilePixelRatio?: number | undefined;
     /**
      * Render tiles beyond the antimeridian.
      */
@@ -103,8 +98,6 @@ export type Options = {
  * @property {import("../tilegrid/TileGrid.js").default} [tileGrid] Tile grid.
  * @property {boolean} [opaque=false] Whether the layer is opaque.
  * @property {import("./Source.js").State} [state] The source state.
- * @property {number} [tilePixelRatio] Deprecated.  To have tiles scaled, pass a `tileSize` representing
- * the source tile size and a `tileGrid` with the desired rendered tile size.
  * @property {boolean} [wrapX=false] Render tiles beyond the antimeridian.
  * @property {number} [transition] Transition time when fading in new tiles (in miliseconds).
  * @property {number} [bandCount=4] Number of bands represented in the data.

package/source/DataTile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataTile.d.ts","sourceRoot":"","sources":["DataTile.js"],"names":[],"mappings":";;;;;4BAiBsB,MAAM,QAAE,MAAM,QAAE,MAAM,KAAI,CAAC,OAAO,gBAAgB,EAAE,IAAI,GAAC,QAAQ,OAAO,gBAAgB,EAAE,IAAI,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBxG,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AApBjD;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;GAMG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAyEjB;IA1CC;;;OAGG;IACH,gBAAgE;IAEhE;;;OAGG;IACH,kBAAmE;IASnE;;;OAGG;IACH,mBAAsB;IAEtB;;;OAGG;IACH,yBAA0B;IAE1B;;OAEG;IACH,gBAA6B;IA8F/B;;;OAGG;IACH,yBAFW,OAAO,oBAAoB,EAAE,OAAO,QAsB9C;IAlHC;;OAEG;IACH,WAFU,MAAM,CAEwD;IAG1E;;;;;OAKG;IACH,kCAFW,MAAM,OAAO,YAAY,EAAE,IAAI,CAAC,QAI1C;IAED;;;;;;OAMG;IACH,yBAHW,MAAM,GACL,OAAO,YAAY,EAAE,IAAI,CAWpC;IAUD;;;OAGG;IACH,4BAHW,MAAM,QAKhB;IAED;;;;;;;OAOG;IACH,WAPW,MAAM,KACN,MAAM,KACN,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACrC,QAAQ,CAgCpB;CA2BF"}
+{"version":3,"file":"DataTile.d.ts","sourceRoot":"","sources":["DataTile.js"],"names":[],"mappings":";;;;;4BAiBsB,MAAM,QAAE,MAAM,QAAE,MAAM,KAAI,CAAC,OAAO,gBAAgB,EAAE,IAAI,GAAC,QAAQ,OAAO,gBAAgB,EAAE,IAAI,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBxG,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AApBjD;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;GAMG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAiEjB;IAnCC;;;OAGG;IACH,gBAAgE;IAEhE;;;OAGG;IACH,kBAAmE;IAEnE;;;OAGG;IACH,mBAAsB;IAEtB;;;OAGG;IACH,yBAA0B;IAE1B;;OAEG;IACH,gBAA6B;IA8F/B;;;OAGG;IACH,yBAFW,OAAO,oBAAoB,EAAE,OAAO,QAsB9C;IAlHC;;OAEG;IACH,WAFU,MAAM,CAEwD;IAG1E;;;;;OAKG;IACH,kCAFW,MAAM,OAAO,YAAY,EAAE,IAAI,CAAC,QAI1C;IAED;;;;;;OAMG;IACH,yBAHW,MAAM,GACL,OAAO,YAAY,EAAE,IAAI,CAWpC;IAUD;;;OAGG;IACH,4BAHW,MAAM,QAKhB;IAED;;;;;;;OAOG;IACH,WAPW,MAAM,KACN,MAAM,KACN,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACrC,QAAQ,CAgCpB;CA2BF"}

package/source/DataTile.js

@@ -36,8 +36,6 @@ import {toSize} from '../size.js';
  * @property {import("../tilegrid/TileGrid.js").default} [tileGrid] Tile grid.
  * @property {boolean} [opaque=false] Whether the layer is opaque.
  * @property {import("./Source.js").State} [state] The source state.
- * @property {number} [tilePixelRatio] Deprecated.  To have tiles scaled, pass a `tileSize` representing
- * the source tile size and a `tileGrid` with the desired rendered tile size.
  * @property {boolean} [wrapX=false] Render tiles beyond the antimeridian.
  * @property {number} [transition] Transition time when fading in new tiles (in miliseconds).
  * @property {number} [bandCount=4] Number of bands represented in the data.
@@ -79,7 +77,6 @@ class DataTileSource extends TileSource {
       tileGrid: tileGrid,
       opaque: options.opaque,
       state: options.state,
-      tilePixelRatio: options.tilePixelRatio,
       wrapX: options.wrapX,
       transition: options.transition,
       interpolate: options.interpolate,
@@ -96,13 +93,6 @@ class DataTileSource extends TileSource {
      * @type {import('../size.js').Size|null}
      */
     this.tileSize_ = options.tileSize ? toSize(options.tileSize) : null;
-    if (!this.tileSize_ && options.tilePixelRatio && tileGrid) {
-      const renderTileSize = toSize(tileGrid.getTileSize(0));
-      this.tileSize_ = [
-        renderTileSize[0] * options.tilePixelRatio,
-        renderTileSize[1] * options.tilePixelRatio,
-      ];
-    }
 
     /**
      * @private

package/source/IIIF.d.ts

@@ -24,10 +24,6 @@ export type Options = {
      * Requested image format.
      */
     format?: string | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.

package/source/IIIF.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IIIF.d.ts","sourceRoot":"","sources":["IIIF.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwBc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;UAMnC,OAAO,YAAY,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBvC;;;;GAIG;AACH;IACE;;;;OAIG;IACH,+CAmSC;CACF"}
+{"version":3,"file":"IIIF.d.ts","sourceRoot":"","sources":["IIIF.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuBc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;UAMnC,OAAO,YAAY,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBvC;;;;GAIG;AACH;IACE;;;;OAIG;IACH,+CA6RC;CACF"}

package/source/IIIF.js

@@ -19,7 +19,6 @@ import {toSize} from '../size.js';
  * @property {null|string} [crossOrigin] The value for the crossOrigin option of the request.
  * @property {import("../extent.js").Extent} [extent=[0, -height, width, 0]] The extent.
  * @property {string} [format='jpg'] Requested image format.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {import("../proj.js").ProjectionLike} [projection] Projection.
@@ -70,12 +69,6 @@ class IIIF extends TileImage {
      */
     const options = opt_options || {};
 
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     let baseUrl = options.url || '';
     baseUrl =
       baseUrl +
@@ -340,7 +333,7 @@ class IIIF extends TileImage {
       attributionsCollapsible: options.attributionsCollapsible,
       cacheSize: options.cacheSize,
       crossOrigin: options.crossOrigin,
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       projection: options.projection,
       reprojectionErrorThreshold: options.reprojectionErrorThreshold,
       state: options.state,

package/source/Image.d.ts

@@ -43,10 +43,6 @@ export type Options = {
      * Attributions.
      */
     attributions?: import("./Source.js").AttributionLike | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -77,7 +73,6 @@ import Event from "../events/Event.js";
 /**
  * @typedef {Object} Options
  * @property {import("./Source.js").AttributionLike} [attributions] Attributions.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {import("../proj.js").ProjectionLike} [projection] Projection.

package/source/Image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Image.d.ts","sourceRoot":"","sources":["Image.js"],"names":[],"mappings":"AAyQA;;;;;GAKG;AACH,gDAHW,OAAO,aAAa,EAAE,OAAO,OAC7B,MAAM,QAIhB;mCAnQS,MAAM;;;;;;AAyBhB;;GAEG;AAEH;;;;GAIG;AACH;IACE;;;OAGG;IACH,kBAHW,MAAM,SACN,OAAO,aAAa,EAAE,OAAO,EAWvC;IANC;;;;OAIG;IACH,OAHU,OAAO,aAAa,EAAE,OAAO,CAGrB;CAErB;;oCAvBY,cAAc,GAAC,gBAAgB,GAAC,gBAAgB;;;;6CA2BhD,OAAO,eAAe,EAAE,WAAW,CAAC,OAAO,eAAe,EAAE,UAAU,EAAE,OAAO,oBAAoB,EAAE,OAAO,EAAE,MAAM,CAAC,GACjI,OAAW,eAAe,EAAE,WAAW,CAAC,OAAO,oBAAoB,EAAE,KAAK,EAAE,OAAO,WAAW,EAAE,WAAW,EAAE,MAAM,CAAC,GACpH,OAAW,eAAe,EAAE,WAAW,CAAC,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,CAAC,GACxF,OAAW,eAAe,EAAE,mBAAmB,CAAC,OAAO,eAAe,EAAE,UAAU,GAAC,OAAO,oBAAoB,EAAE,KAAK,GAC9G,qBAAqB,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;iBASxB,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;AAfjD;;;;;;;GAOG;AAEH;;;;;;;;;GASG;AAEH;;;;;;;;GAQG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAiDjB;IAjCC;;OAEG;IACH,IAFU,uBAAuB,OAAO,WAAW,EAAE,SAAS,CAAC,CAExD;IAEP;;OAEG;IACH,MAFU,uBAAuB,OAAO,WAAW,EAAE,SAAS,CAAC,CAEtD;IAET;;OAEG;IACH,IAFU,uBAAuB,IAAI,CAAC,CAE/B;IAEP;;;OAGG;IACH,qBACgE;IAEhE;;;OAGG;IACH,0BAA6B;IAE7B;;;OAGG;IACH,6BAA6B;IAU/B;;;;OAIG;IACH,4CAHW,MAAM,GACL,MAAM,CAQjB;IAED;;;;;;OAMG;IACH,iBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,iBAAiB,EAAE,OAAO,CAgD5C;IAED;;;;;;;;OAQG;IACH,mCAPW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,iBAAiB,EAAE,OAAO,CAK5C;IAED;;;;OAIG;IACH,mCAHW,OAAO,oBAAoB,EAAE,OAAO,QAyB9C;CACF"}
+{"version":3,"file":"Image.d.ts","sourceRoot":"","sources":["Image.js"],"names":[],"mappings":"AAmQA;;;;;GAKG;AACH,gDAHW,OAAO,aAAa,EAAE,OAAO,OAC7B,MAAM,QAIhB;mCA7PS,MAAM;;;;;;AAyBhB;;GAEG;AAEH;;;;GAIG;AACH;IACE;;;OAGG;IACH,kBAHW,MAAM,SACN,OAAO,aAAa,EAAE,OAAO,EAWvC;IANC;;;;OAIG;IACH,OAHU,OAAO,aAAa,EAAE,OAAO,CAGrB;CAErB;;oCAvBY,cAAc,GAAC,gBAAgB,GAAC,gBAAgB;;;;6CA2BhD,OAAO,eAAe,EAAE,WAAW,CAAC,OAAO,eAAe,EAAE,UAAU,EAAE,OAAO,oBAAoB,EAAE,OAAO,EAAE,MAAM,CAAC,GACjI,OAAW,eAAe,EAAE,WAAW,CAAC,OAAO,oBAAoB,EAAE,KAAK,EAAE,OAAO,WAAW,EAAE,WAAW,EAAE,MAAM,CAAC,GACpH,OAAW,eAAe,EAAE,WAAW,CAAC,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,CAAC,GACxF,OAAW,eAAe,EAAE,mBAAmB,CAAC,OAAO,eAAe,EAAE,UAAU,GAAC,OAAO,oBAAoB,EAAE,KAAK,GAC9G,qBAAqB,EAAE,MAAM,CAAC;;;;;;;;;;;;;;iBAQxB,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;AAdjD;;;;;;;GAOG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EA4CjB;IAjCC;;OAEG;IACH,IAFU,uBAAuB,OAAO,WAAW,EAAE,SAAS,CAAC,CAExD;IAEP;;OAEG;IACH,MAFU,uBAAuB,OAAO,WAAW,EAAE,SAAS,CAAC,CAEtD;IAET;;OAEG;IACH,IAFU,uBAAuB,IAAI,CAAC,CAE/B;IAEP;;;OAGG;IACH,qBACgE;IAEhE;;;OAGG;IACH,0BAA6B;IAE7B;;;OAGG;IACH,6BAA6B;IAU/B;;;;OAIG;IACH,4CAHW,MAAM,GACL,MAAM,CAQjB;IAED;;;;;;OAMG;IACH,iBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,iBAAiB,EAAE,OAAO,CAgD5C;IAED;;;;;;;;OAQG;IACH,mCAPW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,iBAAiB,EAAE,OAAO,CAK5C;IAED;;;;OAIG;IACH,mCAHW,OAAO,oBAAoB,EAAE,OAAO,QAyB9C;CACF"}

package/source/Image.js

@@ -75,7 +75,6 @@ export class ImageSourceEvent extends Event {
 /**
  * @typedef {Object} Options
  * @property {import("./Source.js").AttributionLike} [attributions] Attributions.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {import("../proj.js").ProjectionLike} [projection] Projection.
@@ -97,17 +96,12 @@ class ImageSource extends Source {
    * @param {Options} options Single image source options.
    */
   constructor(options) {
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     super({
       attributions: options.attributions,
       projection: options.projection,
       state: options.state,
-      interpolate: interpolate,
+      interpolate:
+        options.interpolate !== undefined ? options.interpolate : true,
     });
 
     /***

package/source/ImageArcGISRest.d.ts

@@ -20,10 +20,6 @@ export type Options = {
      * a URL.
      */
     imageLoadFunction?: import("../Image.js").LoadFunction | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -72,7 +68,6 @@ export type Options = {
  * the remote server.
  * @property {import("../Image.js").LoadFunction} [imageLoadFunction] Optional function to load an image given
  * a URL.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {Object<string,*>} [params] ArcGIS Rest parameters. This field is optional. Service

package/source/ImageArcGISRest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageArcGISRest.d.ts","sourceRoot":"","sources":["ImageArcGISRest.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Bc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;AAnBjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;;;;;GAWG;AACH;IACE;;OAEG;IACH,+CAyEC;IAzDC;;;OAGG;IACH,qBACgE;IAEhE;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,2BAG8B;IAE9B;;;OAGG;IACH,gBAAmC;IAEnC;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,mBAAwB;IAExB;;;OAGG;IACH,0BAA0B;IAE1B;;;OAGG;IACH,eAA+D;IAGjE;;;;;OAKG;IACH,iBAEC;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,aAAa,EAAE,OAAO,CAgFxC;IAED;;;;OAIG;IACH,wBAHY,OAAO,aAAa,EAAE,YAAY,CAK7C;IAED;;;;;;;;OAQG;IACH,uBAwBC;IAED;;;;OAIG;IACH,UAHY,MAAM,GAAC,SAAS,CAK3B;IAED;;;;OAIG;IACH,wCAHW,OAAO,aAAa,EAAE,YAAY,QAO5C;IAED;;;;OAIG;IACH,YAHW,MAAM,GAAC,SAAS,QAS1B;IAED;;;;OAIG;IACH,gCAIC;CACF"}
+{"version":3,"file":"ImageArcGISRest.d.ts","sourceRoot":"","sources":["ImageArcGISRest.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6Bc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;AAlBjD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;;;;;;;;GAWG;AACH;IACE;;OAEG;IACH,+CAmEC;IAzDC;;;OAGG;IACH,qBACgE;IAEhE;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,2BAG8B;IAE9B;;;OAGG;IACH,gBAAmC;IAEnC;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,mBAAwB;IAExB;;;OAGG;IACH,0BAA0B;IAE1B;;;OAGG;IACH,eAA+D;IAGjE;;;;;OAKG;IACH,iBAEC;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,aAAa,EAAE,OAAO,CAgFxC;IAED;;;;OAIG;IACH,wBAHY,OAAO,aAAa,EAAE,YAAY,CAK7C;IAED;;;;;;;;OAQG;IACH,uBAwBC;IAED;;;;OAIG;IACH,UAHY,MAAM,GAAC,SAAS,CAK3B;IAED;;;;OAIG;IACH,wCAHW,OAAO,aAAa,EAAE,YAAY,QAO5C;IAED;;;;OAIG;IACH,YAHW,MAAM,GAAC,SAAS,QAS1B;IAED;;;;OAIG;IACH,gCAIC;CACF"}

package/source/ImageArcGISRest.js

@@ -19,7 +19,6 @@ import {containsExtent, getHeight, getWidth} from '../extent.js';
  * the remote server.
  * @property {import("../Image.js").LoadFunction} [imageLoadFunction] Optional function to load an image given
  * a URL.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {Object<string,*>} [params] ArcGIS Rest parameters. This field is optional. Service
@@ -58,15 +57,9 @@ class ImageArcGISRest extends ImageSource {
   constructor(opt_options) {
     const options = opt_options ? opt_options : {};
 
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     super({
       attributions: options.attributions,
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       projection: options.projection,
       resolutions: options.resolutions,
     });

package/source/ImageCanvas.d.ts

@@ -26,10 +26,6 @@ export type Options = {
      * invalidate the current cached image. See: {@link module :ol/Observable~Observable#changed}
      */
     canvasFunction?: FunctionType | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -78,7 +74,6 @@ export type Options = {
  * the value returned by the function is later changed then
  * `changed` should be called on the source for the source to
  * invalidate the current cached image. See: {@link module:ol/Observable~Observable#changed}
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {import("../proj.js").ProjectionLike} [projection] Projection. Default is the view projection.

package/source/ImageCanvas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageCanvas.d.ts","sourceRoot":"","sources":["ImageCanvas.js"],"names":[],"mappings":";;;;;;;;;;kCAsB2B,OAAO,mBAAmB,EAAE,OAAO,QAAE,OAAO,cAAc,EAAE,MAAM,QAAE,MAAM,QACpG,MAAY,QAAE,OAAO,YAAY,EAAE,IAAI,QAAE,OAAO,uBAAuB,EAAE,OAAO,KAAG,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBvF,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;AA5BjD;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,+CAwCC;IAvBC;;;OAGG;IACH,wBAA6C;IAE7C;;;OAGG;IACH,gBAAmB;IAEnB;;;OAGG;IACH,0BAA0B;IAE1B;;;OAGG;IACH,eAA+D;IAGjE;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,mBAAmB,EAAE,OAAO,CAqC9C;CACF"}
+{"version":3,"file":"ImageCanvas.d.ts","sourceRoot":"","sources":["ImageCanvas.js"],"names":[],"mappings":";;;;;;;;;;kCAsB2B,OAAO,mBAAmB,EAAE,OAAO,QAAE,OAAO,cAAc,EAAE,MAAM,QAAE,MAAM,QACpG,MAAY,QAAE,OAAO,YAAY,EAAE,IAAI,QAAE,OAAO,uBAAuB,EAAE,OAAO,KAAG,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBvF,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;AA3BjD;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,+CAkCC;IAvBC;;;OAGG;IACH,wBAA6C;IAE7C;;;OAGG;IACH,gBAAmB;IAEnB;;;OAGG;IACH,0BAA0B;IAE1B;;;OAGG;IACH,eAA+D;IAGjE;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,mBAAmB,EAAE,OAAO,CAqC9C;CACF"}

package/source/ImageCanvas.js

@@ -36,7 +36,6 @@ import {
  * the value returned by the function is later changed then
  * `changed` should be called on the source for the source to
  * invalidate the current cached image. See: {@link module:ol/Observable~Observable#changed}
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {import("../proj.js").ProjectionLike} [projection] Projection. Default is the view projection.
@@ -59,15 +58,9 @@ class ImageCanvasSource extends ImageSource {
   constructor(opt_options) {
     const options = opt_options ? opt_options : {};
 
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     super({
       attributions: options.attributions,
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       projection: options.projection,
       resolutions: options.resolutions,
       state: options.state,

package/source/ImageMapGuide.d.ts

@@ -45,10 +45,6 @@ export type Options = {
      * Optional function to load an image given a URL.
      */
     imageLoadFunction?: import("../Image.js").LoadFunction | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -76,7 +72,6 @@ export type Options = {
  * @property {Array<number>} [resolutions] Resolutions.
  * If specified, requests will be made for these resolutions only.
  * @property {import("../Image.js").LoadFunction} [imageLoadFunction] Optional function to load an image given a URL.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {Object} [params] Additional parameters.

package/source/ImageMapGuide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageMapGuide.d.ts","sourceRoot":"","sources":["ImageMapGuide.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Bc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAXjD;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;GAMG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAuFjB;IAxEC;;;OAGG;IACH,qBACgE;IAEhE;;;OAGG;IACH,oBAC4D;IAE5D;;;OAGG;IACH,gBAAmC;IAEnC;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,2BAG8B;IAE9B;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,uBACiE;IAEjE;;;OAGG;IACH,eAA6D;IAE7D;;;OAGG;IACH,oBAC+D;IAE/D;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,0BAA0B;IAG5B;;;;;OAKG;IACH,iBAEC;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,aAAa,EAAE,OAAO,CAoDxC;IAED;;;;OAIG;IACH,wBAHY,OAAO,aAAa,EAAE,YAAY,CAK7C;IAED;;;;OAIG;IACH,gCAGC;IAED;;;;;;;OAOG;IACH,gBAPW,MAAM;YACC,MAAM,GAAE,MAAM,GAAC,MAAM;eAC5B,OAAO,cAAc,EAAE,MAAM,QAC7B,OAAO,YAAY,EAAE,IAAI,cACzB,OAAO,uBAAuB,EAAE,OAAO,GACtC,MAAM,CAsBjB;IAED;;;;OAIG;IACH,wCAHW,OAAO,aAAa,EAAE,YAAY,QAO5C;CACF"}
+{"version":3,"file":"ImageMapGuide.d.ts","sourceRoot":"","sources":["ImageMapGuide.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Bc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;AAXjD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;GAMG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAiFjB;IAxEC;;;OAGG;IACH,qBACgE;IAEhE;;;OAGG;IACH,oBAC4D;IAE5D;;;OAGG;IACH,gBAAmC;IAEnC;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,2BAG8B;IAE9B;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,uBACiE;IAEjE;;;OAGG;IACH,eAA6D;IAE7D;;;OAGG;IACH,oBAC+D;IAE/D;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,0BAA0B;IAG5B;;;;;OAKG;IACH,iBAEC;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,aAAa,EAAE,OAAO,CAoDxC;IAED;;;;OAIG;IACH,wBAHY,OAAO,aAAa,EAAE,YAAY,CAK7C;IAED;;;;OAIG;IACH,gCAGC;IAED;;;;;;;OAOG;IACH,gBAPW,MAAM;YACC,MAAM,GAAE,MAAM,GAAC,MAAM;eAC5B,OAAO,cAAc,EAAE,MAAM,QAC7B,OAAO,YAAY,EAAE,IAAI,cACzB,OAAO,uBAAuB,EAAE,OAAO,GACtC,MAAM,CAsBjB;IAED;;;;OAIG;IACH,wCAHW,OAAO,aAAa,EAAE,YAAY,QAO5C;CACF"}

package/source/ImageMapGuide.js

@@ -31,7 +31,6 @@ import {
  * @property {Array<number>} [resolutions] Resolutions.
  * If specified, requests will be made for these resolutions only.
  * @property {import("../Image.js").LoadFunction} [imageLoadFunction] Optional function to load an image given a URL.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {Object} [params] Additional parameters.
@@ -49,14 +48,8 @@ class ImageMapGuide extends ImageSource {
    * @param {Options} options ImageMapGuide options.
    */
   constructor(options) {
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     super({
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       projection: options.projection,
       resolutions: options.resolutions,
     });

package/source/ImageStatic.d.ts

@@ -19,10 +19,6 @@ export type Options = {
      * Optional function to load an image given a URL.
      */
     imageLoadFunction?: import("../Image.js").LoadFunction | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -51,7 +47,6 @@ export type Options = {
  * @property {import("../extent.js").Extent} [imageExtent] Extent of the image in map coordinates.
  * This is the [left, bottom, right, top] map coordinates of your image.
  * @property {import("../Image.js").LoadFunction} [imageLoadFunction] Optional function to load an image given a URL.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {import("../proj.js").ProjectionLike} [projection] Projection. Default is the view projection.

package/source/ImageStatic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageStatic.d.ts","sourceRoot":"","sources":["ImageStatic.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwBc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;SAGnC,MAAM;;AAfpB;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EA0DjB;IAnCC;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,qBAAuC;IAEvC;;;OAGG;IACH,eAOC;IAED;;;OAGG;IACH,mBAA8D;IAQhE;;;;OAIG;IACH,kBAHY,OAAO,cAAc,EAAE,MAAM,CAKxC;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,aAAa,EAAE,OAAO,CAOxC;IAED;;;;OAIG;IACH,UAHY,MAAM,CAKjB;CAkDF"}
+{"version":3,"file":"ImageStatic.d.ts","sourceRoot":"","sources":["ImageStatic.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuBc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;SAGnC,MAAM;;AAdpB;;;;;;;;;;;;;;;GAeG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAoDjB;IAnCC;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,qBAAuC;IAEvC;;;OAGG;IACH,eAOC;IAED;;;OAGG;IACH,mBAA8D;IAQhE;;;;OAIG;IACH,kBAHY,OAAO,cAAc,EAAE,MAAM,CAKxC;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,aAAa,EAAE,OAAO,CAOxC;IAED;;;;OAIG;IACH,UAHY,MAAM,CAKjB;CAkDF"}

package/source/ImageStatic.js

@@ -19,7 +19,6 @@ import {get as getProjection} from '../proj.js';
  * @property {import("../extent.js").Extent} [imageExtent] Extent of the image in map coordinates.
  * This is the [left, bottom, right, top] map coordinates of your image.
  * @property {import("../Image.js").LoadFunction} [imageLoadFunction] Optional function to load an image given a URL.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {import("../proj.js").ProjectionLike} [projection] Projection. Default is the view projection.
@@ -46,15 +45,9 @@ class Static extends ImageSource {
           ? options.imageLoadFunction
           : defaultImageLoadFunction;
 
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     super({
       attributions: options.attributions,
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       projection: getProjection(options.projection),
     });
 

package/source/ImageWMS.d.ts

@@ -25,10 +25,6 @@ export type Options = {
      * Optional function to load an image given a URL.
      */
     imageLoadFunction?: import("../Image.js").LoadFunction | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -75,7 +71,6 @@ export type Options = {
  * the remote WMS server: `mapserver`, `geoserver`, `carmentaserver`, or `qgis`.
  * Only needed if `hidpi` is `true`.
  * @property {import("../Image.js").LoadFunction} [imageLoadFunction] Optional function to load an image given a URL.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {Object<string,*>} params WMS request parameters.

package/source/ImageWMS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageWMS.d.ts","sourceRoot":"","sources":["ImageWMS.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAiDqB,MAAM;;;;;iBAIb,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;SAMnC,MAAM;;AAzBpB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;GAMG;AACH;IACE;;OAEG;IACH,+CAsFC;IAtEC;;;OAGG;IACH,qBACgE;IAEhE;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,2BAG8B;IAE9B;;;OAGG;IACH,gBAAmC;IAEnC;;;OAGG;IACH,aAAgB;IAGhB;;;OAGG;IACH,oBAAqC;IAErC;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,mBAAwB;IAExB;;;OAGG;IACH,0BAA0B;IAE1B;;;OAGG;IACH,eAA+D;IAGjE;;;;;;;;;;;;;OAaG;IACH,8BAVW,OAAO,kBAAkB,EAAE,UAAU,cACrC,MAAM,cACN,OAAO,YAAY,EAAE,cAAc,gBAKlC,MAAM,GAAC,SAAS,CAiD3B;IAED;;;;;;;;;;;;;OAaG;IACH,6DAHY,MAAM,GAAC,SAAS,CAmC3B;IAED;;;;;OAKG;IACH,iBAEC;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,aAAa,EAAE,OAAO,CAyFxC;IAED;;;;OAIG;IACH,wBAHY,OAAO,aAAa,EAAE,YAAY,CAK7C;IAED;;;;;;;;OAQG;IACH,uBA6CC;IAED;;;;OAIG;IACH,UAHY,MAAM,GAAC,SAAS,CAK3B;IAED;;;;OAIG;IACH,wCAHW,OAAO,aAAa,EAAE,YAAY,QAO5C;IAED;;;;OAIG;IACH,YAHW,MAAM,GAAC,SAAS,QAS1B;IAED;;;;OAIG;IACH,gCAKC;IAED;;OAEG;IACH,mBAGC;CACF"}
+{"version":3,"file":"ImageWMS.d.ts","sourceRoot":"","sources":["ImageWMS.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAgDqB,MAAM;;;;;iBAIb,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;SAMnC,MAAM;;AAxBpB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;GAMG;AACH;IACE;;OAEG;IACH,+CAgFC;IAtEC;;;OAGG;IACH,qBACgE;IAEhE;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,2BAG8B;IAE9B;;;OAGG;IACH,gBAAmC;IAEnC;;;OAGG;IACH,aAAgB;IAGhB;;;OAGG;IACH,oBAAqC;IAErC;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,mBAAwB;IAExB;;;OAGG;IACH,0BAA0B;IAE1B;;;OAGG;IACH,eAA+D;IAGjE;;;;;;;;;;;;;OAaG;IACH,8BAVW,OAAO,kBAAkB,EAAE,UAAU,cACrC,MAAM,cACN,OAAO,YAAY,EAAE,cAAc,gBAKlC,MAAM,GAAC,SAAS,CAiD3B;IAED;;;;;;;;;;;;;OAaG;IACH,6DAHY,MAAM,GAAC,SAAS,CAmC3B;IAED;;;;;OAKG;IACH,iBAEC;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,MAAM,cAC7B,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,aAAa,EAAE,OAAO,CAyFxC;IAED;;;;OAIG;IACH,wBAHY,OAAO,aAAa,EAAE,YAAY,CAK7C;IAED;;;;;;;;OAQG;IACH,uBA6CC;IAED;;;;OAIG;IACH,UAHY,MAAM,GAAC,SAAS,CAK3B;IAED;;;;OAIG;IACH,wCAHW,OAAO,aAAa,EAAE,YAAY,QAO5C;IAED;;;;OAIG;IACH,YAHW,MAAM,GAAC,SAAS,QAS1B;IAED;;;;OAIG;IACH,gCAKC;IAED;;OAEG;IACH,mBAGC;CACF"}

package/source/ImageWMS.js

@@ -44,7 +44,6 @@ const GETFEATUREINFO_IMAGE_SIZE = [101, 101];
  * the remote WMS server: `mapserver`, `geoserver`, `carmentaserver`, or `qgis`.
  * Only needed if `hidpi` is `true`.
  * @property {import("../Image.js").LoadFunction} [imageLoadFunction] Optional function to load an image given a URL.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {Object<string,*>} params WMS request parameters.
@@ -74,15 +73,9 @@ class ImageWMS extends ImageSource {
   constructor(opt_options) {
     const options = opt_options ? opt_options : {};
 
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     super({
       attributions: options.attributions,
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       projection: options.projection,
       resolutions: options.resolutions,
     });

package/source/OGCMapTile.d.ts

@@ -34,10 +34,6 @@ export type Options = {
      * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
      */
     crossOrigin?: string | null | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -82,7 +78,6 @@ export type Options = {
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {number} [reprojectionErrorThreshold=0.5] Maximum allowed reprojection error (in pixels).

package/source/OGCMapTile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OGCMapTile.d.ts","sourceRoot":"","sources":["OGCMapTile.js"],"names":[],"mappings":";;;;;SAQc,MAAM;;;;;;;;;;;;;;;;iBAKN,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAPjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;GAKG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAgCjB;IAED;;;OAGG;IACH,2BAIC;IAED;;;OAGG;IACH,qBAGC;CACF"}
+{"version":3,"file":"OGCMapTile.d.ts","sourceRoot":"","sources":["OGCMapTile.js"],"names":[],"mappings":";;;;;SAQc,MAAM;;;;;;;;;;;;;;;;iBAKN,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAPjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;GAKG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EA0BjB;IAED;;;OAGG;IACH,2BAIC;IAED;;;OAGG;IACH,qBAGC;CACF"}

package/source/OGCMapTile.js

@@ -19,7 +19,6 @@ import {getTileSetInfo} from './ogcTileUtil.js';
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {number} [reprojectionErrorThreshold=0.5] Maximum allowed reprojection error (in pixels).
@@ -46,17 +45,11 @@ class OGCMapTile extends TileImage {
    * @param {Options} options OGC map tile options.
    */
   constructor(options) {
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     super({
       attributions: options.attributions,
       cacheSize: options.cacheSize,
       crossOrigin: options.crossOrigin,
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       projection: options.projection,
       reprojectionErrorThreshold: options.reprojectionErrorThreshold,
       state: 'loading',

package/source/OSM.d.ts

@@ -22,10 +22,6 @@ export type Options = {
      * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
      */
     crossOrigin?: string | null | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -80,7 +76,6 @@ export type Options = {
  * @property {null|string} [crossOrigin='anonymous'] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {number} [maxZoom=19] Max zoom.

package/source/OSM.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OSM.d.ts","sourceRoot":"","sources":["OSM.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,0BAHU,MAAM,CAME;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,+CAuCC;CACF"}
+{"version":3,"file":"OSM.d.ts","sourceRoot":"","sources":["OSM.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,0BAHU,MAAM,CAME;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,+CAiCC;CACF"}

package/source/OSM.js

@@ -23,7 +23,6 @@ export const ATTRIBUTION =
  * @property {null|string} [crossOrigin='anonymous'] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {number} [maxZoom=19] Max zoom.
@@ -58,12 +57,6 @@ class OSM extends XYZ {
   constructor(opt_options) {
     const options = opt_options || {};
 
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     let attributions;
     if (options.attributions !== undefined) {
       attributions = options.attributions;
@@ -84,7 +77,7 @@ class OSM extends XYZ {
       attributionsCollapsible: false,
       cacheSize: options.cacheSize,
       crossOrigin: crossOrigin,
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       maxZoom: options.maxZoom !== undefined ? options.maxZoom : 19,
       opaque: options.opaque !== undefined ? options.opaque : true,
       reprojectionErrorThreshold: options.reprojectionErrorThreshold,

package/source/Stamen.d.ts

@@ -4,10 +4,6 @@ export type Options = {
      * Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
      */
     cacheSize?: number | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -61,7 +57,6 @@ export type Options = {
 /**
  * @typedef {Object} Options
  * @property {number} [cacheSize] Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {string} layer Layer name.

package/source/Stamen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Stamen.d.ts","sourceRoot":"","sources":["Stamen.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;WA4Fc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AANpB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAwCjB;CACF"}
+{"version":3,"file":"Stamen.d.ts","sourceRoot":"","sources":["Stamen.js"],"names":[],"mappings":";;;;;;;;;;;;;;WA2Fc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AALpB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAkCjB;CACF"}

package/source/Stamen.js

@@ -87,7 +87,6 @@ const ProviderConfig = {
 /**
  * @typedef {Object} Options
  * @property {number} [cacheSize] Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {string} layer Layer name.
@@ -121,12 +120,6 @@ class Stamen extends XYZ {
    * @param {Options} options Stamen options.
    */
   constructor(options) {
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     const i = options.layer.indexOf('-');
     const provider = i == -1 ? options.layer : options.layer.slice(0, i);
     const providerConfig = ProviderConfig[provider];
@@ -145,7 +138,7 @@ class Stamen extends XYZ {
       attributions: ATTRIBUTIONS,
       cacheSize: options.cacheSize,
       crossOrigin: 'anonymous',
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       maxZoom:
         options.maxZoom != undefined ? options.maxZoom : providerConfig.maxZoom,
       minZoom:

package/source/TileArcGISRest.d.ts

@@ -14,10 +14,6 @@ export type Options = {
      * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
      */
     crossOrigin?: string | null | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -101,7 +97,6 @@ export type Options = {
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {Object<string,*>} [params] ArcGIS Rest parameters. This field is optional. Service defaults will be

package/source/TileArcGISRest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TileArcGISRest.d.ts","sourceRoot":"","sources":["TileArcGISRest.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAxBjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;;;;;GAQG;AACH;IACE;;OAEG;IACH,+CA4CC;IAnBC;;;OAGG;IACH,gBAAmC;IAEnC;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,mBAA+B;IAKjC;;;OAGG;IACH,yBAOC;IAED;;;;;OAKG;IACH,iBAEC;IAED;;;;;;;;;OASG;IACH,uBAyCC;IAWD;;;;OAIG;IACH,gCAGC;CA+CF"}
+{"version":3,"file":"TileArcGISRest.d.ts","sourceRoot":"","sources":["TileArcGISRest.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAvBjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;;;;;;;GAQG;AACH;IACE;;OAEG;IACH,+CAsCC;IAnBC;;;OAGG;IACH,gBAAmC;IAEnC;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,mBAA+B;IAKjC;;;OAGG;IACH,yBAOC;IAED;;;;;OAKG;IACH,iBAEC;IAED;;;;;;;;;OASG;IACH,uBAyCC;IAWD;;;;OAIG;IACH,gCAGC;CA+CF"}

package/source/TileArcGISRest.js

@@ -16,7 +16,6 @@ import {hash as tileCoordHash} from '../tilecoord.js';
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {Object<string,*>} [params] ArcGIS Rest parameters. This field is optional. Service defaults will be
@@ -73,17 +72,11 @@ class TileArcGISRest extends TileImage {
   constructor(opt_options) {
     const options = opt_options ? opt_options : {};
 
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     super({
       attributions: options.attributions,
       cacheSize: options.cacheSize,
       crossOrigin: options.crossOrigin,
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       projection: options.projection,
       reprojectionErrorThreshold: options.reprojectionErrorThreshold,
       tileGrid: options.tileGrid,

package/source/TileImage.d.ts

@@ -18,10 +18,6 @@ export type Options = {
      * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
      */
     crossOrigin?: string | null | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -113,7 +109,6 @@ export type Options = {
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {boolean} [opaque=false] Whether the layer is opaque.

package/source/TileImage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TileImage.d.ts","sourceRoot":"","sources":["TileImage.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Bc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAZjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH;;;;;;GAMG;AACH;IACE;;OAEG;IACH,qBAFY,OAAO,EAoElB;IArCC;;;OAGG;IACH,uBAFW,MAAM,QAG+C;IAEhE;;;OAGG;IACH,qBAFU,gBAAgB,CAGuC;IAEjE;;;OAGG;IACH;YAFkB,MAAM,GAAE,SAAS;MAEH;IAEhC;;;OAGG;IACH;YAFkB,MAAM,GAAE,OAAO,yBAAyB,EAAE,OAAO;MAEpC;IAE/B;;;OAGG;IACH,oCAAqE;IAErE;;;OAGG;IACH,iCAAqC;IA2DvC;;OAEG;IACH,aAFY,MAAM,CAIjB;IA0ED;;;;;;;;;OASG;IACH,oBAoBC;IAED;;;;;;;OAOG;IACH,WAPW,MAAM,KACN,MAAM,KACN,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACrC,CAAC,SAAS,GAAC,UAAU,CAAC,CA+DlC;IAED;;;;;;;;OAQG;IACH,6BARW,MAAM,KACN,MAAM,KACN,MAAM,cACN,MAAM,cACL,OAAO,uBAAuB,EAAE,OAAO,GACtC,CAAC,SAAS,GAAC,UAAU,CAAC,CA+BlC;IAED;;;;OAIG;IACH,mCAHW,OAAO,QAejB;IAED;;;;;;;;;;;OAWG;IACH,qCAJW,OAAO,YAAY,EAAE,cAAc,YACnC,OAAO,yBAAyB,EAAE,OAAO,QAanD;CACF"}
+{"version":3,"file":"TileImage.d.ts","sourceRoot":"","sources":["TileImage.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0Bc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAXjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;GAMG;AACH;IACE;;OAEG;IACH,qBAFY,OAAO,EA+DlB;IArCC;;;OAGG;IACH,uBAFW,MAAM,QAG+C;IAEhE;;;OAGG;IACH,qBAFU,gBAAgB,CAGuC;IAEjE;;;OAGG;IACH;YAFkB,MAAM,GAAE,SAAS;MAEH;IAEhC;;;OAGG;IACH;YAFkB,MAAM,GAAE,OAAO,yBAAyB,EAAE,OAAO;MAEpC;IAE/B;;;OAGG;IACH,oCAAqE;IAErE;;;OAGG;IACH,iCAAqC;IA2DvC;;OAEG;IACH,aAFY,MAAM,CAIjB;IA0ED;;;;;;;;;OASG;IACH,oBAoBC;IAED;;;;;;;OAOG;IACH,WAPW,MAAM,KACN,MAAM,KACN,MAAM,cACN,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACrC,CAAC,SAAS,GAAC,UAAU,CAAC,CA+DlC;IAED;;;;;;;;OAQG;IACH,6BARW,MAAM,KACN,MAAM,KACN,MAAM,cACN,MAAM,cACL,OAAO,uBAAuB,EAAE,OAAO,GACtC,CAAC,SAAS,GAAC,UAAU,CAAC,CA+BlC;IAED;;;;OAIG;IACH,mCAHW,OAAO,QAejB;IAED;;;;;;;;;;;OAWG;IACH,qCAJW,OAAO,YAAY,EAAE,cAAc,YACnC,OAAO,yBAAyB,EAAE,OAAO,QAanD;CACF"}

package/source/TileImage.js

@@ -21,7 +21,6 @@ import {getUid} from '../util.js';
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {boolean} [opaque=false] Whether the layer is opaque.
@@ -71,12 +70,6 @@ class TileImage extends UrlTile {
    * @param {!Options} options Image tile options.
    */
   constructor(options) {
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     super({
       attributions: options.attributions,
       cacheSize: options.cacheSize,
@@ -93,7 +86,8 @@ class TileImage extends UrlTile {
       urls: options.urls,
       wrapX: options.wrapX,
       transition: options.transition,
-      interpolate: interpolate,
+      interpolate:
+        options.interpolate !== undefined ? options.interpolate : true,
       key: options.key,
       attributionsCollapsible: options.attributionsCollapsible,
       zDirection: options.zDirection,

package/source/TileJSON.d.ts

@@ -68,10 +68,6 @@ export type Options = {
      * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
      */
     crossOrigin?: string | null | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -148,7 +144,6 @@ export type Options = {
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {boolean} [jsonp=false] Use JSONP with callback to load the TileJSON.

package/source/TileJSON.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TileJSON.d.ts","sourceRoot":"","sources":["TileJSON.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA0Bc,MAAM,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAT3B;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAsDjB;IA/BC;;;OAGG;IACH,kBAAqB;IAErB;;;OAGG;IACH,kBAAiC;IAuBnC;;;OAGG;IACH,mBAeC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,eAHY,MAAM,CAKjB;IAED;;;OAGG;IACH,2CAFW,MAAM,QAuChB;IAED;;OAEG;IACH,sCAEC;CACF"}
+{"version":3,"file":"TileJSON.d.ts","sourceRoot":"","sources":["TileJSON.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA0Bc,MAAM,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAT3B;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAgDjB;IA/BC;;;OAGG;IACH,kBAAqB;IAErB;;;OAGG;IACH,kBAAiC;IAuBnC;;;OAGG;IACH,mBAeC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,eAHY,MAAM,CAKjB;IAED;;;OAGG;IACH,2CAFW,MAAM,QAuChB;IAED;;OAEG;IACH,sCAEC;CACF"}

package/source/TileJSON.js

@@ -39,7 +39,6 @@ import {jsonp as requestJSONP} from '../net.js';
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {boolean} [jsonp=false] Use JSONP with callback to load the TileJSON.
@@ -75,17 +74,11 @@ class TileJSON extends TileImage {
    * @param {Options} options TileJSON options.
    */
   constructor(options) {
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     super({
       attributions: options.attributions,
       cacheSize: options.cacheSize,
       crossOrigin: options.crossOrigin,
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       projection: getProjection('EPSG:3857'),
       reprojectionErrorThreshold: options.reprojectionErrorThreshold,
       state: 'loading',

package/source/TileWMS.d.ts

@@ -18,10 +18,6 @@ export type Options = {
      * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
      */
     crossOrigin?: string | null | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -124,7 +120,6 @@ export type Options = {
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {Object<string,*>} params WMS request parameters.

package/source/TileWMS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TileWMS.d.ts","sourceRoot":"","sources":["TileWMS.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA2BqB,MAAM;;;;;;;;;;;;;;;;;;;;;iBAeb,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA1BjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,+CAsEC;IAtCC;;;OAGG;IACH,gBAAgE;IAEhE;;;OAGG;IACH,gBAAqB;IAErB;;;OAGG;IACH,aAAgB;IAEhB;;;OAGG;IACH,oBAAqC;IAErC;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,mBAA+B;IAMjC;;;;;;;;;;;;;OAaG;IACH,8BAVW,OAAO,kBAAkB,EAAE,UAAU,cACrC,MAAM,cACN,OAAO,YAAY,EAAE,cAAc,gBAKlC,MAAM,GAAC,SAAS,CAoE3B;IAED;;;;;;;;;;;;;OAaG;IACH,6DAHY,MAAM,GAAC,SAAS,CAmC3B;IASD;;;;;OAKG;IACH,iBAEC;IAED;;;;;;;;;OASG;IACH,uBAkEC;IAWD;;;OAGG;IACH,yBAOC;IAED;;;;OAIG;IACH,gCAIC;IAED;;OAEG;IACH,mBAGC;CAuDF"}
+{"version":3,"file":"TileWMS.d.ts","sourceRoot":"","sources":["TileWMS.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA0BqB,MAAM;;;;;;;;;;;;;;;;;;;;;iBAeb,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAzBjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,+CAgEC;IAtCC;;;OAGG;IACH,gBAAgE;IAEhE;;;OAGG;IACH,gBAAqB;IAErB;;;OAGG;IACH,aAAgB;IAEhB;;;OAGG;IACH,oBAAqC;IAErC;;;OAGG;IACH,eAAgE;IAEhE;;;OAGG;IACH,mBAA+B;IAMjC;;;;;;;;;;;;;OAaG;IACH,8BAVW,OAAO,kBAAkB,EAAE,UAAU,cACrC,MAAM,cACN,OAAO,YAAY,EAAE,cAAc,gBAKlC,MAAM,GAAC,SAAS,CAoE3B;IAED;;;;;;;;;;;;;OAaG;IACH,6DAHY,MAAM,GAAC,SAAS,CAmC3B;IASD;;;;;OAKG;IACH,iBAEC;IAED;;;;;;;;;OASG;IACH,uBAkEC;IAWD;;;OAGG;IACH,yBAOC;IAED;;;;OAIG;IACH,gCAIC;IAED;;OAEG;IACH,mBAGC;CAuDF"}

package/source/TileWMS.js

@@ -22,7 +22,6 @@ import {hash as tileCoordHash} from '../tilecoord.js';
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {Object<string,*>} params WMS request parameters.
@@ -85,12 +84,6 @@ class TileWMS extends TileImage {
   constructor(opt_options) {
     const options = opt_options ? opt_options : /** @type {Options} */ ({});
 
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     const params = options.params || {};
 
     const transparent = 'TRANSPARENT' in params ? params['TRANSPARENT'] : true;
@@ -100,7 +93,7 @@ class TileWMS extends TileImage {
       attributionsCollapsible: options.attributionsCollapsible,
       cacheSize: options.cacheSize,
       crossOrigin: options.crossOrigin,
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       opaque: !transparent,
       projection: options.projection,
       reprojectionErrorThreshold: options.reprojectionErrorThreshold,

package/source/WMTS.d.ts

@@ -47,10 +47,6 @@ export type Options = {
      * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
      */
     crossOrigin?: string | null | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -158,7 +154,6 @@ export type Options = {
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {import("../tilegrid/WMTS.js").default} tileGrid Tile grid.

package/source/WMTS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WMTS.d.ts","sourceRoot":"","sources":["WMTS.js"],"names":[],"mappings":"AA0VA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,oEAHY,OAAO,GAAC,IAAI,CAyOvB;;;;;8BA3kBY,KAAK,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAcb,OAAO,qBAAqB,EAAE,OAAO;;;;iBACrC,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;WAInC,MAAM;;;;WACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;eAQN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA9BpB;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EA8FjB;IArDC;;;OAGG;IACH,iBAAyE;IAEzE;;;OAGG;IACH,gBAA2E;IAE3E;;;OAGG;IACH,oBAC4D;IAE5D;;;OAGG;IACH,eAA2B;IAE3B;;;OAGG;IACH,mBAAmC;IAEnC;;;OAGG;IACH,eAA2B;IAK3B;;;OAGG;IACH,yBAAuC;IA2BzC;;;;;;OAMG;IACH,qBAEC;IAED;;;;OAIG;IACH,aAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,YAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,gBAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,sBAHY,eAAe,CAK1B;IAED;;;;OAIG;IACH,YAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,cAHY,MAAM,CAKjB;IAED;;;OAGG;IACH,6BAOC;IAED;;;;OAIG;IACH,wCAGC;IAED;;;OAGG;IACH,iCAHW,MAAM,GACL,OAAO,YAAY,EAAE,WAAW,CAmE3C;CACF"}
+{"version":3,"file":"WMTS.d.ts","sourceRoot":"","sources":["WMTS.js"],"names":[],"mappings":"AAmVA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,oEAHY,OAAO,GAAC,IAAI,CAyOvB;;;;;8BApkBY,KAAK,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAab,OAAO,qBAAqB,EAAE,OAAO;;;;iBACrC,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;WAInC,MAAM;;;;WACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;eAQN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA7BpB;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;GAIG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAwFjB;IArDC;;;OAGG;IACH,iBAAyE;IAEzE;;;OAGG;IACH,gBAA2E;IAE3E;;;OAGG;IACH,oBAC4D;IAE5D;;;OAGG;IACH,eAA2B;IAE3B;;;OAGG;IACH,mBAAmC;IAEnC;;;OAGG;IACH,eAA2B;IAK3B;;;OAGG;IACH,yBAAuC;IA2BzC;;;;;;OAMG;IACH,qBAEC;IAED;;;;OAIG;IACH,aAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,YAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,gBAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,sBAHY,eAAe,CAK1B;IAED;;;;OAIG;IACH,YAHY,MAAM,CAKjB;IAED;;;;OAIG;IACH,cAHY,MAAM,CAKjB;IAED;;;OAGG;IACH,6BAOC;IAED;;;;OAIG;IACH,wCAGC;IAED;;;OAGG;IACH,iCAHW,MAAM,GACL,OAAO,YAAY,EAAE,WAAW,CAmE3C;CACF"}

package/source/WMTS.js

@@ -22,7 +22,6 @@ import {equivalent, get as getProjection, transformExtent} from '../proj.js';
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {import("../tilegrid/WMTS.js").default} tileGrid Tile grid.
@@ -73,12 +72,6 @@ class WMTS extends TileImage {
    * @param {Options} options WMTS options.
    */
   constructor(options) {
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     // TODO: add support for TileMatrixLimits
 
     const requestEncoding =
@@ -98,7 +91,7 @@ class WMTS extends TileImage {
       attributionsCollapsible: options.attributionsCollapsible,
       cacheSize: options.cacheSize,
       crossOrigin: options.crossOrigin,
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       projection: options.projection,
       reprojectionErrorThreshold: options.reprojectionErrorThreshold,
       tileClass: options.tileClass,

package/source/XYZ.d.ts

@@ -18,10 +18,6 @@ export type Options = {
      * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
      */
     crossOrigin?: string | null | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -122,7 +118,6 @@ export type Options = {
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {boolean} [opaque=false] Whether the layer is opaque.

package/source/XYZ.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"XYZ.d.ts","sourceRoot":"","sources":["XYZ.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAZjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IACE;;OAEG;IACH,+CAgDC;IALC;;;OAGG;IACH,gBAAgE;CASnE"}
+{"version":3,"file":"XYZ.d.ts","sourceRoot":"","sources":["XYZ.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBc,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAXjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IACE;;OAEG;IACH,+CA0CC;IALC;;;OAGG;IACH,gBAAgE;CASnE"}

package/source/XYZ.js

@@ -13,7 +13,6 @@ import {createXYZ, extentFromProjection} from '../tilegrid.js';
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {boolean} [opaque=false] Whether the layer is opaque.
@@ -78,12 +77,6 @@ class XYZ extends TileImage {
   constructor(opt_options) {
     const options = opt_options || {};
 
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     const projection =
       options.projection !== undefined ? options.projection : 'EPSG:3857';
 
@@ -102,7 +95,7 @@ class XYZ extends TileImage {
       attributions: options.attributions,
       cacheSize: options.cacheSize,
       crossOrigin: options.crossOrigin,
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       opaque: options.opaque,
       projection: projection,
       reprojectionErrorThreshold: options.reprojectionErrorThreshold,

package/source/Zoomify.d.ts

@@ -39,10 +39,6 @@ export type Options = {
      * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
      */
     crossOrigin?: string | null | undefined;
-    /**
-     * Deprecated.  Use the `interpolate` option instead.
-     */
-    imageSmoothing?: boolean | undefined;
     /**
      * Use interpolated values when resampling.  By default,
      * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
@@ -114,7 +110,6 @@ import ImageTile from "../ImageTile.js";
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value  you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {import("../proj.js").ProjectionLike} [projection] Projection.

package/source/Zoomify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Zoomify.d.ts","sourceRoot":"","sources":["Zoomify.js"],"names":[],"mappings":"AAeA;;GAEG;AAEH;IACE;;;;;;;;OAQG;IACH,sBARW,OAAO,YAAY,EAAE,IAAI,aACzB,OAAO,iBAAiB,EAAE,SAAS,mBAEnC,MAAM,eACL,MAAM,2BACP,OAAO,YAAY,EAAE,YAAY,0DAwB3C;IAVC;;;OAGG;IACH,sBAAyB;IAEzB;;OAEG;IACH,WAFU,OAAO,YAAY,EAAE,IAAI,CAEV;CA2B5B;;kCA5DY,SAAS,GAAG,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwEtB,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;SAInC,MAAM;;;;;;;;UAYN,OAAO,YAAY,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;AA1BvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;GAKG;AACH;IACE;;OAEG;IACH,yBAFW,OAAO,EA6KjB;CACF"}
+{"version":3,"file":"Zoomify.d.ts","sourceRoot":"","sources":["Zoomify.js"],"names":[],"mappings":"AAeA;;GAEG;AAEH;IACE;;;;;;;;OAQG;IACH,sBARW,OAAO,YAAY,EAAE,IAAI,aACzB,OAAO,iBAAiB,EAAE,SAAS,mBAEnC,MAAM,eACL,MAAM,2BACP,OAAO,YAAY,EAAE,YAAY,0DAwB3C;IAVC;;;OAGG;IACH,sBAAyB;IAEzB;;OAEG;IACH,WAFU,OAAO,YAAY,EAAE,IAAI,CAEV;CA2B5B;;kCA5DY,SAAS,GAAG,WAAW;;;;;;;;;;;;;;;;;;;;;;;;iBAuEtB,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;SAInC,MAAM;;;;;;;;UAYN,OAAO,YAAY,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;AAzBvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH;;;;;GAKG;AACH;IACE;;OAEG;IACH,yBAFW,OAAO,EAuKjB;CACF"}

package/source/Zoomify.js

@@ -83,7 +83,6 @@ export class CustomTile extends ImageTile {
  * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that
  * you must provide a `crossOrigin` value  you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {boolean} [imageSmoothing=true] Deprecated.  Use the `interpolate` option instead.
  * @property {boolean} [interpolate=true] Use interpolated values when resampling.  By default,
  * linear interpolation is used when resampling.  Set to false to use the nearest neighbor instead.
  * @property {import("../proj.js").ProjectionLike} [projection] Projection.
@@ -129,12 +128,6 @@ class Zoomify extends TileImage {
   constructor(opt_options) {
     const options = opt_options;
 
-    let interpolate =
-      options.imageSmoothing !== undefined ? options.imageSmoothing : true;
-    if (options.interpolate !== undefined) {
-      interpolate = options.interpolate;
-    }
-
     const size = options.size;
     const tierSizeCalculation =
       options.tierSizeCalculation !== undefined
@@ -264,7 +257,7 @@ class Zoomify extends TileImage {
       attributions: options.attributions,
       cacheSize: options.cacheSize,
       crossOrigin: options.crossOrigin,
-      interpolate: interpolate,
+      interpolate: options.interpolate,
       projection: options.projection,
       tilePixelRatio: tilePixelRatio,
       reprojectionErrorThreshold: options.reprojectionErrorThreshold,