ol 7.0.0-dev.1660306204497 → 7.0.0-dev.1660487589130

package/View.js

@@ -288,7 +288,7 @@ const DEFAULT_MIN_ZOOM = 0;
  * A consequence of this is that, when applying a delta on the view state, one
  * should use `adjustCenter`, `adjustRotation`, `adjustZoom` and `adjustResolution`
  * rather than the corresponding setters. This will let view do its internal
- * computations. Besides, the `adjust*` methods also take an `opt_anchor`
+ * computations. Besides, the `adjust*` methods also take an `anchor`
  * argument which allows specifying an origin for the transformation.
  *
  * ### Interacting with the view
@@ -303,9 +303,9 @@ const DEFAULT_MIN_ZOOM = 0;
  */
 class View extends BaseObject {
   /**
-   * @param {ViewOptions} [opt_options] View options.
+   * @param {ViewOptions} [options] View options.
    */
-  constructor(opt_options) {
+  constructor(options) {
     super();
 
     /***
@@ -323,7 +323,7 @@ class View extends BaseObject {
      */
     this.un;
 
-    const options = Object.assign({}, opt_options);
+    options = Object.assign({}, options);
 
     /**
      * @private
@@ -896,19 +896,17 @@ class View extends BaseObject {
   /**
    * Returns the current viewport size.
    * @private
-   * @param {number} [opt_rotation] Take into account the rotation of the viewport when giving the size
+   * @param {number} [rotation] Take into account the rotation of the viewport when giving the size
    * @return {import("./size.js").Size} Viewport size or `[100, 100]` when no viewport is found.
    */
-  getViewportSize_(opt_rotation) {
+  getViewportSize_(rotation) {
     const size = this.viewportSize_;
-    if (opt_rotation) {
+    if (rotation) {
       const w = size[0];
       const h = size[1];
       return [
-        Math.abs(w * Math.cos(opt_rotation)) +
-          Math.abs(h * Math.sin(opt_rotation)),
-        Math.abs(w * Math.sin(opt_rotation)) +
-          Math.abs(h * Math.cos(opt_rotation)),
+        Math.abs(w * Math.cos(rotation)) + Math.abs(h * Math.sin(rotation)),
+        Math.abs(w * Math.sin(rotation)) + Math.abs(h * Math.cos(rotation)),
       ];
     } else {
       return size;
@@ -920,12 +918,10 @@ class View extends BaseObject {
    * to avoid performance hit and layout reflow.
    * This should be done on map size change.
    * Note: the constraints are not resolved during an animation to avoid stopping it
-   * @param {import("./size.js").Size} [opt_size] Viewport size; if undefined, [100, 100] is assumed
+   * @param {import("./size.js").Size} [size] Viewport size; if undefined, [100, 100] is assumed
    */
-  setViewportSize(opt_size) {
-    this.viewportSize_ = Array.isArray(opt_size)
-      ? opt_size.slice()
-      : [100, 100];
+  setViewportSize(size) {
+    this.viewportSize_ = Array.isArray(size) ? size.slice() : [100, 100];
     if (!this.getAnimating()) {
       this.resolveConstraints(0);
     }
@@ -970,14 +966,14 @@ class View extends BaseObject {
   }
 
   /**
-   * @param {Array<number>} [opt_hints] Destination array.
+   * @param {Array<number>} [hints] Destination array.
    * @return {Array<number>} Hint.
    */
-  getHints(opt_hints) {
-    if (opt_hints !== undefined) {
-      opt_hints[0] = this.hints_[0];
-      opt_hints[1] = this.hints_[1];
-      return opt_hints;
+  getHints(hints) {
+    if (hints !== undefined) {
+      hints[0] = this.hints_[0];
+      hints[1] = this.hints_[1];
+      return hints;
     } else {
       return this.hints_.slice();
     }
@@ -988,23 +984,23 @@ class View extends BaseObject {
    * The size is the pixel dimensions of the box into which the calculated extent
    * should fit. In most cases you want to get the extent of the entire map,
    * that is `map.getSize()`.
-   * @param {import("./size.js").Size} [opt_size] Box pixel size. If not provided, the size
+   * @param {import("./size.js").Size} [size] Box pixel size. If not provided, the size
    * of the map that uses this view will be used.
    * @return {import("./extent.js").Extent} Extent.
    * @api
    */
-  calculateExtent(opt_size) {
-    const extent = this.calculateExtentInternal(opt_size);
+  calculateExtent(size) {
+    const extent = this.calculateExtentInternal(size);
     return toUserExtent(extent, this.getProjection());
   }
 
   /**
-   * @param {import("./size.js").Size} [opt_size] Box pixel size. If not provided,
+   * @param {import("./size.js").Size} [size] Box pixel size. If not provided,
    * the map's last known viewport size will be used.
    * @return {import("./extent.js").Extent} Extent.
    */
-  calculateExtentInternal(opt_size) {
-    const size = opt_size || this.getViewportSizeMinusPadding_();
+  calculateExtentInternal(size) {
+    size = size || this.getViewportSizeMinusPadding_();
     const center = /** @type {!import("./coordinate.js").Coordinate} */ (
       this.getCenterInternal()
     );
@@ -1116,27 +1112,27 @@ class View extends BaseObject {
   /**
    * Get the resolution for a provided extent (in map units) and size (in pixels).
    * @param {import("./extent.js").Extent} extent Extent.
-   * @param {import("./size.js").Size} [opt_size] Box pixel size.
+   * @param {import("./size.js").Size} [size] Box pixel size.
    * @return {number} The resolution at which the provided extent will render at
    *     the given size.
    * @api
    */
-  getResolutionForExtent(extent, opt_size) {
+  getResolutionForExtent(extent, size) {
     return this.getResolutionForExtentInternal(
       fromUserExtent(extent, this.getProjection()),
-      opt_size
+      size
     );
   }
 
   /**
    * Get the resolution for a provided extent (in map units) and size (in pixels).
    * @param {import("./extent.js").Extent} extent Extent.
-   * @param {import("./size.js").Size} [opt_size] Box pixel size.
+   * @param {import("./size.js").Size} [size] Box pixel size.
    * @return {number} The resolution at which the provided extent will render at
    *     the given size.
    */
-  getResolutionForExtentInternal(extent, opt_size) {
-    const size = opt_size || this.getViewportSizeMinusPadding_();
+  getResolutionForExtentInternal(extent, size) {
+    size = size || this.getViewportSizeMinusPadding_();
     const xResolution = getWidth(extent) / size[0];
     const yResolution = getHeight(extent) / size[1];
     return Math.max(xResolution, yResolution);
@@ -1145,11 +1141,11 @@ class View extends BaseObject {
   /**
    * Return a function that returns a value between 0 and 1 for a
    * resolution. Exponential scaling is assumed.
-   * @param {number} [opt_power] Power.
+   * @param {number} [power] Power.
    * @return {function(number): number} Resolution for value function.
    */
-  getResolutionForValueFunction(opt_power) {
-    const power = opt_power || 2;
+  getResolutionForValueFunction(power) {
+    power = power || 2;
     const maxResolution = this.getConstrainedResolution(this.maxResolution_);
     const minResolution = this.minResolution_;
     const max = Math.log(maxResolution / minResolution) / Math.log(power);
@@ -1178,11 +1174,11 @@ class View extends BaseObject {
   /**
    * Return a function that returns a resolution for a value between
    * 0 and 1. Exponential scaling is assumed.
-   * @param {number} [opt_power] Power.
+   * @param {number} [power] Power.
    * @return {function(number): number} Value for resolution function.
    */
-  getValueForResolutionFunction(opt_power) {
-    const logPower = Math.log(opt_power || 2);
+  getValueForResolutionFunction(power) {
+    const logPower = Math.log(power || 2);
     const maxResolution = this.getConstrainedResolution(this.maxResolution_);
     const minResolution = this.minResolution_;
     const max = Math.log(maxResolution / minResolution) / logPower;
@@ -1201,11 +1197,11 @@ class View extends BaseObject {
   /**
    * Returns the size of the viewport minus padding.
    * @private
-   * @param {number} [opt_rotation] Take into account the rotation of the viewport when giving the size
+   * @param {number} [rotation] Take into account the rotation of the viewport when giving the size
    * @return {import("./size.js").Size} Viewport size reduced by the padding.
    */
-  getViewportSizeMinusPadding_(opt_rotation) {
-    let size = this.getViewportSize_(opt_rotation);
+  getViewportSizeMinusPadding_(rotation) {
+    let size = this.getViewportSize_(rotation);
     const padding = this.padding_;
     if (padding) {
       size = [
@@ -1326,10 +1322,10 @@ class View extends BaseObject {
    * Takes care of the map angle.
    * @param {import("./geom/SimpleGeometry.js").default|import("./extent.js").Extent} geometryOrExtent The geometry or
    *     extent to fit the view to.
-   * @param {FitOptions} [opt_options] Options.
+   * @param {FitOptions} [options] Options.
    * @api
    */
-  fit(geometryOrExtent, opt_options) {
+  fit(geometryOrExtent, options) {
     /** @type {import("./geom/SimpleGeometry.js").default} */
     let geometry;
     assert(
@@ -1362,7 +1358,7 @@ class View extends BaseObject {
       }
     }
 
-    this.fitInternal(geometry, opt_options);
+    this.fitInternal(geometry, options);
   }
 
   /**
@@ -1393,10 +1389,10 @@ class View extends BaseObject {
 
   /**
    * @param {import("./geom/SimpleGeometry.js").default} geometry The geometry.
-   * @param {FitOptions} [opt_options] Options.
+   * @param {FitOptions} [options] Options.
    */
-  fitInternal(geometry, opt_options) {
-    const options = opt_options || {};
+  fitInternal(geometry, options) {
+    options = options || {};
     let size = options.size;
     if (!size) {
       size = this.getViewportSizeMinusPadding_();
@@ -1551,12 +1547,11 @@ class View extends BaseObject {
    * Multiply the view resolution by a ratio, optionally using an anchor. Any resolution
    * constraint will apply.
    * @param {number} ratio The ratio to apply on the view resolution.
-   * @param {import("./coordinate.js").Coordinate} [opt_anchor] The origin of the transformation.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
    * @api
    */
-  adjustResolution(ratio, opt_anchor) {
-    const anchor =
-      opt_anchor && fromUserCoordinate(opt_anchor, this.getProjection());
+  adjustResolution(ratio, anchor) {
+    anchor = anchor && fromUserCoordinate(anchor, this.getProjection());
     this.adjustResolutionInternal(ratio, anchor);
   }
 
@@ -1564,9 +1559,9 @@ class View extends BaseObject {
    * Multiply the view resolution by a ratio, optionally using an anchor. Any resolution
    * constraint will apply.
    * @param {number} ratio The ratio to apply on the view resolution.
-   * @param {import("./coordinate.js").Coordinate} [opt_anchor] The origin of the transformation.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
    */
-  adjustResolutionInternal(ratio, opt_anchor) {
+  adjustResolutionInternal(ratio, anchor) {
     const isMoving = this.getAnimating() || this.getInteracting();
     const size = this.getViewportSize_(this.getRotation());
     const newResolution = this.constraints_.resolution(
@@ -1576,8 +1571,8 @@ class View extends BaseObject {
       isMoving
     );
 
-    if (opt_anchor) {
-      this.targetCenter_ = this.calculateCenterZoom(newResolution, opt_anchor);
+    if (anchor) {
+      this.targetCenter_ = this.calculateCenterZoom(newResolution, anchor);
     }
 
     this.targetResolution_ *= ratio;
@@ -1588,39 +1583,39 @@ class View extends BaseObject {
    * Adds a value to the view zoom level, optionally using an anchor. Any resolution
    * constraint will apply.
    * @param {number} delta Relative value to add to the zoom level.
-   * @param {import("./coordinate.js").Coordinate} [opt_anchor] The origin of the transformation.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
    * @api
    */
-  adjustZoom(delta, opt_anchor) {
-    this.adjustResolution(Math.pow(this.zoomFactor_, -delta), opt_anchor);
+  adjustZoom(delta, anchor) {
+    this.adjustResolution(Math.pow(this.zoomFactor_, -delta), anchor);
   }
 
   /**
    * Adds a value to the view rotation, optionally using an anchor. Any rotation
    * constraint will apply.
    * @param {number} delta Relative value to add to the zoom rotation, in radians.
-   * @param {import("./coordinate.js").Coordinate} [opt_anchor] The rotation center.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The rotation center.
    * @api
    */
-  adjustRotation(delta, opt_anchor) {
-    if (opt_anchor) {
-      opt_anchor = fromUserCoordinate(opt_anchor, this.getProjection());
+  adjustRotation(delta, anchor) {
+    if (anchor) {
+      anchor = fromUserCoordinate(anchor, this.getProjection());
     }
-    this.adjustRotationInternal(delta, opt_anchor);
+    this.adjustRotationInternal(delta, anchor);
   }
 
   /**
    * @param {number} delta Relative value to add to the zoom rotation, in radians.
-   * @param {import("./coordinate.js").Coordinate} [opt_anchor] The rotation center.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The rotation center.
    */
-  adjustRotationInternal(delta, opt_anchor) {
+  adjustRotationInternal(delta, anchor) {
     const isMoving = this.getAnimating() || this.getInteracting();
     const newRotation = this.constraints_.rotation(
       this.targetRotation_ + delta,
       isMoving
     );
-    if (opt_anchor) {
-      this.targetCenter_ = this.calculateCenterRotate(newRotation, opt_anchor);
+    if (anchor) {
+      this.targetCenter_ = this.calculateCenterRotate(newRotation, anchor);
     }
     this.targetRotation_ += delta;
     this.applyTargetState_();
@@ -1693,13 +1688,13 @@ class View extends BaseObject {
    * Recompute rotation/resolution/center based on target values.
    * Note: we have to compute rotation first, then resolution and center considering that
    * parameters can influence one another in case a view extent constraint is present.
-   * @param {boolean} [opt_doNotCancelAnims] Do not cancel animations.
-   * @param {boolean} [opt_forceMoving] Apply constraints as if the view is moving.
+   * @param {boolean} [doNotCancelAnims] Do not cancel animations.
+   * @param {boolean} [forceMoving] Apply constraints as if the view is moving.
    * @private
    */
-  applyTargetState_(opt_doNotCancelAnims, opt_forceMoving) {
+  applyTargetState_(doNotCancelAnims, forceMoving) {
     const isMoving =
-      this.getAnimating() || this.getInteracting() || opt_forceMoving;
+      this.getAnimating() || this.getInteracting() || forceMoving;
 
     // compute rotation
     const newRotation = this.constraints_.rotation(
@@ -1741,7 +1736,7 @@ class View extends BaseObject {
       this.set(ViewProperty.CENTER, newCenter);
     }
 
-    if (this.getAnimating() && !opt_doNotCancelAnims) {
+    if (this.getAnimating() && !doNotCancelAnims) {
       this.cancelAnimations();
     }
     this.cancelAnchor_ = undefined;
@@ -1752,13 +1747,13 @@ class View extends BaseObject {
    * This is typically done on interaction end.
    * Note: calling this with a duration of 0 will apply the constrained values straight away,
    * without animation.
-   * @param {number} [opt_duration] The animation duration in ms.
-   * @param {number} [opt_resolutionDirection] Which direction to zoom.
-   * @param {import("./coordinate.js").Coordinate} [opt_anchor] The origin of the transformation.
+   * @param {number} [duration] The animation duration in ms.
+   * @param {number} [resolutionDirection] Which direction to zoom.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
    */
-  resolveConstraints(opt_duration, opt_resolutionDirection, opt_anchor) {
-    const duration = opt_duration !== undefined ? opt_duration : 200;
-    const direction = opt_resolutionDirection || 0;
+  resolveConstraints(duration, resolutionDirection, anchor) {
+    duration = duration !== undefined ? duration : 200;
+    const direction = resolutionDirection || 0;
 
     const newRotation = this.constraints_.rotation(this.targetRotation_);
     const size = this.getViewportSize_(newRotation);
@@ -1788,8 +1783,7 @@ class View extends BaseObject {
       return;
     }
 
-    const anchor =
-      opt_anchor || (duration === 0 ? this.cancelAnchor_ : undefined);
+    anchor = anchor || (duration === 0 ? this.cancelAnchor_ : undefined);
     this.cancelAnchor_ = undefined;
 
     if (
@@ -1828,42 +1822,41 @@ class View extends BaseObject {
   /**
    * Notify the View that an interaction has ended. The view state will be resolved
    * to a stable one if needed (depending on its constraints).
-   * @param {number} [opt_duration] Animation duration in ms.
-   * @param {number} [opt_resolutionDirection] Which direction to zoom.
-   * @param {import("./coordinate.js").Coordinate} [opt_anchor] The origin of the transformation.
+   * @param {number} [duration] Animation duration in ms.
+   * @param {number} [resolutionDirection] Which direction to zoom.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
    * @api
    */
-  endInteraction(opt_duration, opt_resolutionDirection, opt_anchor) {
-    const anchor =
-      opt_anchor && fromUserCoordinate(opt_anchor, this.getProjection());
-    this.endInteractionInternal(opt_duration, opt_resolutionDirection, anchor);
+  endInteraction(duration, resolutionDirection, anchor) {
+    anchor = anchor && fromUserCoordinate(anchor, this.getProjection());
+    this.endInteractionInternal(duration, resolutionDirection, anchor);
   }
 
   /**
    * Notify the View that an interaction has ended. The view state will be resolved
    * to a stable one if needed (depending on its constraints).
-   * @param {number} [opt_duration] Animation duration in ms.
-   * @param {number} [opt_resolutionDirection] Which direction to zoom.
-   * @param {import("./coordinate.js").Coordinate} [opt_anchor] The origin of the transformation.
+   * @param {number} [duration] Animation duration in ms.
+   * @param {number} [resolutionDirection] Which direction to zoom.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
    */
-  endInteractionInternal(opt_duration, opt_resolutionDirection, opt_anchor) {
+  endInteractionInternal(duration, resolutionDirection, anchor) {
     this.setHint(ViewHint.INTERACTING, -1);
 
-    this.resolveConstraints(opt_duration, opt_resolutionDirection, opt_anchor);
+    this.resolveConstraints(duration, resolutionDirection, anchor);
   }
 
   /**
    * Get a valid position for the view center according to the current constraints.
    * @param {import("./coordinate.js").Coordinate|undefined} targetCenter Target center position.
-   * @param {number} [opt_targetResolution] Target resolution. If not supplied, the current one will be used.
+   * @param {number} [targetResolution] Target resolution. If not supplied, the current one will be used.
    * This is useful to guess a valid center position at a different zoom level.
    * @return {import("./coordinate.js").Coordinate|undefined} Valid center position.
    */
-  getConstrainedCenter(targetCenter, opt_targetResolution) {
+  getConstrainedCenter(targetCenter, targetResolution) {
     const size = this.getViewportSize_(this.getRotation());
     return this.constraints_.center(
       targetCenter,
-      opt_targetResolution || this.getResolution(),
+      targetResolution || this.getResolution(),
       size
     );
   }
@@ -1871,30 +1864,30 @@ class View extends BaseObject {
   /**
    * Get a valid zoom level according to the current view constraints.
    * @param {number|undefined} targetZoom Target zoom.
-   * @param {number} [opt_direction=0] Indicate which resolution should be used
+   * @param {number} [direction=0] Indicate which resolution should be used
    * by a renderer if the view resolution does not match any resolution of the tile source.
    * If 0, the nearest resolution will be used. If 1, the nearest lower resolution
    * will be used. If -1, the nearest higher resolution will be used.
    * @return {number|undefined} Valid zoom level.
    */
-  getConstrainedZoom(targetZoom, opt_direction) {
+  getConstrainedZoom(targetZoom, direction) {
     const targetRes = this.getResolutionForZoom(targetZoom);
     return this.getZoomForResolution(
-      this.getConstrainedResolution(targetRes, opt_direction)
+      this.getConstrainedResolution(targetRes, direction)
     );
   }
 
   /**
    * Get a valid resolution according to the current view constraints.
    * @param {number|undefined} targetResolution Target resolution.
-   * @param {number} [opt_direction=0] Indicate which resolution should be used
+   * @param {number} [direction=0] Indicate which resolution should be used
    * by a renderer if the view resolution does not match any resolution of the tile source.
    * If 0, the nearest resolution will be used. If 1, the nearest lower resolution
    * will be used. If -1, the nearest higher resolution will be used.
    * @return {number|undefined} Valid resolution.
    */
-  getConstrainedResolution(targetResolution, opt_direction) {
-    const direction = opt_direction || 0;
+  getConstrainedResolution(targetResolution, direction) {
+    direction = direction || 0;
     const size = this.getViewportSize_(this.getRotation());
 
     return this.constraints_.resolution(targetResolution, direction, size);

package/array.d.ts

@@ -7,10 +7,10 @@
  *
  * @param {Array<*>} haystack Items to search through.
  * @param {*} needle The item to look for.
- * @param {Function} [opt_comparator] Comparator function.
+ * @param {Function} [comparator] Comparator function.
  * @return {number} The index of the item if found, -1 if not.
  */
-export function binarySearch(haystack: Array<any>, needle: any, opt_comparator?: Function | undefined): number;
+export function binarySearch(haystack: Array<any>, needle: any, comparator?: Function | undefined): number;
 /**
  * Compare function for array sort that is safe for numbers.
  * @param {*} a The first object to be compared.
@@ -77,11 +77,11 @@ export function equals(arr1: any[] | Uint8ClampedArray, arr2: any[] | Uint8Clamp
 export function stableSort(arr: Array<any>, compareFnc: (arg0: any, arg1: any) => number): void;
 /**
  * @param {Array<*>} arr The array to test.
- * @param {Function} [opt_func] Comparison function.
- * @param {boolean} [opt_strict] Strictly sorted (default false).
+ * @param {Function} [func] Comparison function.
+ * @param {boolean} [strict] Strictly sorted (default false).
  * @return {boolean} Return index.
  */
-export function isSorted(arr: Array<any>, opt_func?: Function | undefined, opt_strict?: boolean | undefined): boolean;
+export function isSorted(arr: Array<any>, func?: Function | undefined, strict?: boolean | undefined): boolean;
 /**
  * {@link module :ol/tilegrid/TileGrid~TileGrid#getZForResolution} can use a function
  * of this type to determine which nearest resolution to use.

package/array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["array.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;GAQG;AACH,uCALW,UAAQ,uDAGP,MAAM,CA2BjB;AAED;;;;;;GAMG;AACH,2DAHY,MAAM,CAKjB;AAED;;;;;;;;;;;;GAYG;AAEH;;;;;;;;GAQG;AACH,uCARW,MAAM,MAAM,CAAC,UACb,MAAM,aACN,MAAM,GAAC,wBAAwB,GAI9B,MAAM,CA2CjB;AAED;;;;GAIG;AACH,qCAJW,UAAQ,SACR,MAAM,OACN,MAAM,QAUhB;AAED;;;;GAIG;AACH,yEAMC;AAED;;;;;GAKG;AACH,yDAFY,OAAO,CASlB;AAED;;;;GAIG;AACH,6BAJW,QAAM,iBAAiB,QACvB,QAAM,iBAAiB,GACtB,OAAO,CAalB;AAED;;;;;;GAMG;AACH,gCAJW,UAAQ,wCACS,MAAM,QAgBjC;AAED;;;;;GAKG;AACH,8BALW,UAAQ,sEAGP,OAAO,CAWlB;;;;;;;;;;;;8CA1JqB,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,MAAM"}
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["array.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;GAQG;AACH,uCALW,UAAQ,mDAGP,MAAM,CA2BjB;AAED;;;;;;GAMG;AACH,2DAHY,MAAM,CAKjB;AAED;;;;;;;;;;;;GAYG;AAEH;;;;;;;;GAQG;AACH,uCARW,MAAM,MAAM,CAAC,UACb,MAAM,aACN,MAAM,GAAC,wBAAwB,GAI9B,MAAM,CA2CjB;AAED;;;;GAIG;AACH,qCAJW,UAAQ,SACR,MAAM,OACN,MAAM,QAUhB;AAED;;;;GAIG;AACH,yEAMC;AAED;;;;;GAKG;AACH,yDAFY,OAAO,CASlB;AAED;;;;GAIG;AACH,6BAJW,QAAM,iBAAiB,QACvB,QAAM,iBAAiB,GACtB,OAAO,CAalB;AAED;;;;;;GAMG;AACH,gCAJW,UAAQ,wCACS,MAAM,QAgBjC;AAED;;;;;GAKG;AACH,8BALW,UAAQ,8DAGP,OAAO,CAWlB;;;;;;;;;;;;8CA1JqB,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,MAAM"}

package/array.js

@@ -8,12 +8,12 @@
  *
  * @param {Array<*>} haystack Items to search through.
  * @param {*} needle The item to look for.
- * @param {Function} [opt_comparator] Comparator function.
+ * @param {Function} [comparator] Comparator function.
  * @return {number} The index of the item if found, -1 if not.
  */
-export function binarySearch(haystack, needle, opt_comparator) {
+export function binarySearch(haystack, needle, comparator) {
   let mid, cmp;
-  const comparator = opt_comparator || numberSafeCompareFunction;
+  comparator = comparator || numberSafeCompareFunction;
   let low = 0;
   let high = haystack.length;
   let found = false;
@@ -200,17 +200,17 @@ export function stableSort(arr, compareFnc) {
 
 /**
  * @param {Array<*>} arr The array to test.
- * @param {Function} [opt_func] Comparison function.
- * @param {boolean} [opt_strict] Strictly sorted (default false).
+ * @param {Function} [func] Comparison function.
+ * @param {boolean} [strict] Strictly sorted (default false).
  * @return {boolean} Return index.
  */
-export function isSorted(arr, opt_func, opt_strict) {
-  const compare = opt_func || numberSafeCompareFunction;
+export function isSorted(arr, func, strict) {
+  const compare = func || numberSafeCompareFunction;
   return arr.every(function (currentVal, index) {
     if (index === 0) {
       return true;
     }
     const res = compare(arr[index - 1], currentVal);
-    return !(res > 0 || (opt_strict && res === 0));
+    return !(res > 0 || (strict && res === 0));
   });
 }

package/centerconstraint.js

@@ -20,11 +20,11 @@ export function createExtent(extent, onlyCenter, smooth) {
      * @param {import("./coordinate.js").Coordinate|undefined} center Center.
      * @param {number|undefined} resolution Resolution.
      * @param {import("./size.js").Size} size Viewport size; unused if `onlyCenter` was specified.
-     * @param {boolean} [opt_isMoving] True if an interaction or animation is in progress.
-     * @param {Array<number>} [opt_centerShift] Shift between map center and viewport center.
+     * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+     * @param {Array<number>} [centerShift] Shift between map center and viewport center.
      * @return {import("./coordinate.js").Coordinate|undefined} Center.
      */
-    function (center, resolution, size, opt_isMoving, opt_centerShift) {
+    function (center, resolution, size, isMoving, centerShift) {
       if (!center) {
         return undefined;
       }
@@ -33,8 +33,8 @@ export function createExtent(extent, onlyCenter, smooth) {
       }
       const viewWidth = onlyCenter ? 0 : size[0] * resolution;
       const viewHeight = onlyCenter ? 0 : size[1] * resolution;
-      const shiftX = opt_centerShift ? opt_centerShift[0] : 0;
-      const shiftY = opt_centerShift ? opt_centerShift[1] : 0;
+      const shiftX = centerShift ? centerShift[0] : 0;
+      const shiftY = centerShift ? centerShift[1] : 0;
       let minX = extent[0] + viewWidth / 2 + shiftX;
       let maxX = extent[2] - viewWidth / 2 + shiftX;
       let minY = extent[1] + viewHeight / 2 + shiftY;
@@ -55,7 +55,7 @@ export function createExtent(extent, onlyCenter, smooth) {
       let y = clamp(center[1], minY, maxY);
 
       // during an interaction, allow some overscroll
-      if (opt_isMoving && smooth && resolution) {
+      if (isMoving && smooth && resolution) {
         const ratio = 30 * resolution;
         x +=
           -ratio * Math.log(1 + Math.max(0, minX - center[0]) / ratio) +

package/control/Attribution.d.ts

@@ -91,9 +91,9 @@ export type Options = {
  */
 declare class Attribution extends Control {
     /**
-     * @param {Options} [opt_options] Attribution options.
+     * @param {Options} [options] Attribution options.
      */
-    constructor(opt_options?: Options | undefined);
+    constructor(options?: Options | undefined);
     /**
      * @private
      * @type {HTMLElement}

package/control/Attribution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Attribution.d.ts","sourceRoot":"","sources":["Attribution.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgCuB,OAAO,gBAAgB,EAAE,OAAO,KAAE,IAAI;;AAtB7D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;;;GAQG;AACH;IACE;;OAEG;IACH,+CAsIC;IA7HC;;;OAGG;IACH,mBAA8C;IAE9C;;;OAGG;IACH,mBAC4D;IAE5D;;;OAGG;IACH,uBAAqC;IAErC;;;OAGG;IACH,6BAA6D;IAE7D;;;OAGG;IACH,qBACgE;IA0B9D;;;OAGG;IACH,uBAAoD;IAUpD;;;OAGG;IACH,eAA4C;IAU9C;;;OAGG;IACH,sBAAqD;IAyBrD;;;;OAIG;IACH,8BAA+B;IAE/B;;;OAGG;IACH,yBAA4B;IAG9B;;;;;OAKG;IACH,mCA2DC;IAED;;;OAGG;IACH,uBA+BC;IAED;;;OAGG;IACH,qBAIC;IAED;;OAEG;IACH,sBASC;IAED;;;;OAIG;IACH,kBAHY,OAAO,CAKlB;IAED;;;;OAIG;IACH,4BAHW,OAAO,QAYjB;IAED;;;;;;OAMG;IACH,wBAHW,OAAO,QASjB;IAED;;;;;OAKG;IACH,gBAHY,OAAO,CAKlB;CAUF"}
+{"version":3,"file":"Attribution.d.ts","sourceRoot":"","sources":["Attribution.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgCuB,OAAO,gBAAgB,EAAE,OAAO,KAAE,IAAI;;AAtB7D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;;;GAQG;AACH;IACE;;OAEG;IACH,2CAsIC;IA7HC;;;OAGG;IACH,mBAA8C;IAE9C;;;OAGG;IACH,mBAC4D;IAE5D;;;OAGG;IACH,uBAAqC;IAErC;;;OAGG;IACH,6BAA6D;IAE7D;;;OAGG;IACH,qBACgE;IA0B9D;;;OAGG;IACH,uBAAoD;IAUpD;;;OAGG;IACH,eAA4C;IAU9C;;;OAGG;IACH,sBAAqD;IAyBrD;;;;OAIG;IACH,8BAA+B;IAE/B;;;OAGG;IACH,yBAA4B;IAG9B;;;;;OAKG;IACH,mCA2DC;IAED;;;OAGG;IACH,uBA+BC;IAED;;;OAGG;IACH,qBAIC;IAED;;OAEG;IACH,sBASC;IAED;;;;OAIG;IACH,kBAHY,OAAO,CAKlB;IAED;;;;OAIG;IACH,4BAHW,OAAO,QAYjB;IAED;;;;;;OAMG;IACH,wBAHW,OAAO,QASjB;IAED;;;;;OAKG;IACH,gBAHY,OAAO,CAKlB;CAUF"}

package/control/Attribution.js

@@ -46,10 +46,10 @@ import {removeChildren, replaceNode} from '../dom.js';
  */
 class Attribution extends Control {
   /**
-   * @param {Options} [opt_options] Attribution options.
+   * @param {Options} [options] Attribution options.
    */
-  constructor(opt_options) {
-    const options = opt_options ? opt_options : {};
+  constructor(options) {
+    options = options ? options : {};
 
     super({
       element: document.createElement('div'),

package/control/FullScreen.d.ts

@@ -94,9 +94,9 @@ export type Options = {
  */
 declare class FullScreen extends Control {
     /**
-     * @param {Options} [opt_options] Options.
+     * @param {Options} [options] Options.
      */
-    constructor(opt_options?: Options | undefined);
+    constructor(options?: Options | undefined);
     /***
      * @type {FullScreenOnSignature<import("../events").EventsKey>}
      */

package/control/FullScreen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FullScreen.d.ts","sourceRoot":"","sources":["FullScreen.js"],"names":[],"mappings":";;;;4CAqCa,OAAO,eAAe,EAAE,WAAW,CAAC,OAAO,eAAe,EAAE,UAAU,GAClF,iBAAuB,GAAC,iBAAiB,EAAE,OAAO,oBAAoB,EAAE,OAAO,EAAE,MAAM,CAAC,GACxF,OAAW,eAAe,EAAE,WAAW,CAAC,OAAO,oBAAoB,EAAE,KAAK,EAAE,OAAO,WAAW,EAAE,WAAW,EAAE,MAAM,CAAC,GACpH,OAAW,eAAe,EAAE,mBAAmB,CAAC,OAAO,eAAe,EAAE,UAAU,GAClF,iBAAuB,GAAC,iBAAiB,GAAC,OAAO,oBAAoB,EAAE,KAAK,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AANtF;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IACE;;OAEG;IACH,+CAqHC;IA7GC;;OAEG;IACH,IAFU,sBAAsB,OAAO,WAAW,EAAE,SAAS,CAAC,CAEvD;IAEP;;OAEG;IACH,MAFU,sBAAsB,OAAO,WAAW,EAAE,SAAS,CAAC,CAErD;IAET;;OAEG;IACH,IAFU,sBAAsB,IAAI,CAAC,CAE9B;IAEP;;;OAGG;IACH,cAA8D;IAE9D;;;OAGG;IACH,gBAA6B;IAE7B;;;OAGG;IACH,wBAA4B;IAE5B;;OAEG;IACH,oCAAyE;IAEzE;;;OAGG;IACH,sBACwE;IAExE;;;OAGG;IACH,2BAA4B;IAE5B;;;OAGG;IACH,yBAGoC;IAEpC;;;OAGG;IACH,2BAGqC;IAIrC;;;OAGG;IACH,mBACoE;IAKpE;;;OAGG;IACH,yBAGiB;IAIjB;;;OAGG;IACH,gBAA+C;IAejD;;;OAGG;IACH,qBAGC;IAED;;OAEG;IACH,0BA2BC;IAED;;OAEG;IACH,gCAkBC;IAED;;;;OAIG;IACH,sBAQC;IA8BD;;OAEG;IACH,+BAuBC;CACF"}
+{"version":3,"file":"FullScreen.d.ts","sourceRoot":"","sources":["FullScreen.js"],"names":[],"mappings":";;;;4CAqCa,OAAO,eAAe,EAAE,WAAW,CAAC,OAAO,eAAe,EAAE,UAAU,GAClF,iBAAuB,GAAC,iBAAiB,EAAE,OAAO,oBAAoB,EAAE,OAAO,EAAE,MAAM,CAAC,GACxF,OAAW,eAAe,EAAE,WAAW,CAAC,OAAO,oBAAoB,EAAE,KAAK,EAAE,OAAO,WAAW,EAAE,WAAW,EAAE,MAAM,CAAC,GACpH,OAAW,eAAe,EAAE,mBAAmB,CAAC,OAAO,eAAe,EAAE,UAAU,GAClF,iBAAuB,GAAC,iBAAiB,GAAC,OAAO,oBAAoB,EAAE,KAAK,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AANtF;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IACE;;OAEG;IACH,2CAqHC;IA7GC;;OAEG;IACH,IAFU,sBAAsB,OAAO,WAAW,EAAE,SAAS,CAAC,CAEvD;IAEP;;OAEG;IACH,MAFU,sBAAsB,OAAO,WAAW,EAAE,SAAS,CAAC,CAErD;IAET;;OAEG;IACH,IAFU,sBAAsB,IAAI,CAAC,CAE9B;IAEP;;;OAGG;IACH,cAA8D;IAE9D;;;OAGG;IACH,gBAA6B;IAE7B;;;OAGG;IACH,wBAA4B;IAE5B;;OAEG;IACH,oCAAyE;IAEzE;;;OAGG;IACH,sBACwE;IAExE;;;OAGG;IACH,2BAA4B;IAE5B;;;OAGG;IACH,yBAGoC;IAEpC;;;OAGG;IACH,2BAGqC;IAIrC;;;OAGG;IACH,mBACoE;IAKpE;;;OAGG;IACH,yBAGiB;IAIjB;;;OAGG;IACH,gBAA+C;IAejD;;;OAGG;IACH,qBAGC;IAED;;OAEG;IACH,0BA2BC;IAED;;OAEG;IACH,gCAkBC;IAED;;;;OAIG;IACH,sBAQC;IA8BD;;OAEG;IACH,+BAuBC;CACF"}

package/control/FullScreen.js

@@ -80,10 +80,10 @@ const FullScreenEventType = {
  */
 class FullScreen extends Control {
   /**
-   * @param {Options} [opt_options] Options.
+   * @param {Options} [options] Options.
    */
-  constructor(opt_options) {
-    const options = opt_options ? opt_options : {};
+  constructor(options) {
+    options = options ? options : {};
 
     super({
       element: document.createElement('div'),