@cesium/engine 1.1.0 → 2.1.0

package/Source/Core/SteppedSpline.js

@@ -9,9 +9,9 @@ import Spline from "./Spline.js";
  * @alias SteppedSpline
  * @constructor
  *
- * @param {Object} options Object with the following properties:
- * @param {Number[]} options.times An array of strictly increasing, unit-less, floating-point times at each point. The values are in no way connected to the clock time. They are the parameterization for the curve.
- * @param {Number[]|Cartesian3[]|Quaternion[]} options.points The array of control points.
+ * @param {object} options Object with the following properties:
+ * @param {number[]} options.times An array of strictly increasing, unit-less, floating-point times at each point. The values are in no way connected to the clock time. They are the parameterization for the curve.
+ * @param {number[]|Cartesian3[]|Quaternion[]} options.points The array of control points.
  *
  * @exception {DeveloperError} points.length must be greater than or equal to 2.
  * @exception {DeveloperError} times.length must be equal to points.length.
@@ -71,7 +71,7 @@ Object.defineProperties(SteppedSpline.prototype, {
    *
    * @memberof SteppedSpline.prototype
    *
-   * @type {Number[]}
+   * @type {number[]}
    * @readonly
    */
   times: {
@@ -85,7 +85,7 @@ Object.defineProperties(SteppedSpline.prototype, {
    *
    * @memberof SteppedSpline.prototype
    *
-   * @type {Number[]|Cartesian3[]|Quaternion[]}
+   * @type {number[]|Cartesian3[]|Quaternion[]}
    * @readonly
    */
   points: {
@@ -100,9 +100,9 @@ Object.defineProperties(SteppedSpline.prototype, {
  * <code>time</code> is in the interval <code>[times[i], times[i + 1]]</code>.
  * @function
  *
- * @param {Number} time The time.
- * @param {Number} startIndex The index from which to start the search.
- * @returns {Number} The index for the element at the start of the interval.
+ * @param {number} time The time.
+ * @param {number} startIndex The index from which to start the search.
+ * @returns {number} The index for the element at the start of the interval.
  *
  * @exception {DeveloperError} time must be in the range <code>[t<sub>0</sub>, t<sub>n</sub>]</code>, where <code>t<sub>0</sub></code>
  *                             is the first element in the array <code>times</code> and <code>t<sub>n</sub></code> is the last element
@@ -114,8 +114,8 @@ SteppedSpline.prototype.findTimeInterval = Spline.prototype.findTimeInterval;
  * Wraps the given time to the period covered by the spline.
  * @function
  *
- * @param {Number} time The time.
- * @return {Number} The time, wrapped around to the updated animation.
+ * @param {number} time The time.
+ * @return {number} The time, wrapped around to the updated animation.
  */
 SteppedSpline.prototype.wrapTime = Spline.prototype.wrapTime;
 
@@ -123,17 +123,17 @@ SteppedSpline.prototype.wrapTime = Spline.prototype.wrapTime;
  * Clamps the given time to the period covered by the spline.
  * @function
  *
- * @param {Number} time The time.
- * @return {Number} The time, clamped to the animation period.
+ * @param {number} time The time.
+ * @return {number} The time, clamped to the animation period.
  */
 SteppedSpline.prototype.clampTime = Spline.prototype.clampTime;
 
 /**
  * Evaluates the curve at a given time.
  *
- * @param {Number} time The time at which to evaluate the curve.
+ * @param {number} time The time at which to evaluate the curve.
  * @param {Cartesian3|Quaternion} [result] The object onto which to store the result.
- * @returns {Number|Cartesian3|Quaternion} The modified result parameter or a new instance of the point on the curve at the given time.
+ * @returns {number|Cartesian3|Quaternion} The modified result parameter or a new instance of the point on the curve at the given time.
  *
  * @exception {DeveloperError} time must be in the range <code>[t<sub>0</sub>, t<sub>n</sub>]</code>, where <code>t<sub>0</sub></code>
  *                             is the first element in the array <code>times</code> and <code>t<sub>n</sub></code> is the last element

package/Source/Core/TaskProcessor.js

@@ -195,8 +195,8 @@ function getWebAssemblyLoaderConfig(processor, wasmOptions) {
  * @alias TaskProcessor
  * @constructor
  *
- * @param {String} workerPath The Url to the worker. This can either be an absolute path or relative to the Cesium Workers folder.
- * @param {Number} [maximumActiveTasks=Number.POSITIVE_INFINITY] The maximum number of active tasks.  Once exceeded,
+ * @param {string} workerPath The Url to the worker. This can either be an absolute path or relative to the Cesium Workers folder.
+ * @param {number} [maximumActiveTasks=Number.POSITIVE_INFINITY] The maximum number of active tasks.  Once exceeded,
  *                                        scheduleTask will not queue any more tasks, allowing
  *                                        work to be rescheduled in future frames.
  */
@@ -223,10 +223,10 @@ const emptyTransferableObjectArray = [];
  * Otherwise, returns a promise that will resolve to the result posted back by the worker when
  * finished.
  *
- * @param {Object} parameters Any input data that will be posted to the worker.
+ * @param {object} parameters Any input data that will be posted to the worker.
  * @param {Object[]} [transferableObjects] An array of objects contained in parameters that should be
  *                                      transferred to the worker instead of copied.
- * @returns {Promise.<Object>|undefined} Either a promise that will resolve to the result when available, or undefined
+ * @returns {Promise<object>|undefined} Either a promise that will resolve to the result when available, or undefined
  *                    if there are too many active tasks,
  *
  * @example
@@ -289,11 +289,11 @@ TaskProcessor.prototype.scheduleTask = function (
  * and compiling a web assembly module asychronously, as well as an optional
  * fallback JavaScript module to use if Web Assembly is not supported.
  *
- * @param {Object} [webAssemblyOptions] An object with the following properties:
- * @param {String} [webAssemblyOptions.modulePath] The path of the web assembly JavaScript wrapper module.
- * @param {String} [webAssemblyOptions.wasmBinaryFile] The path of the web assembly binary file.
- * @param {String} [webAssemblyOptions.fallbackModulePath] The path of the fallback JavaScript module to use if web assembly is not supported.
- * @returns {Promise.<Object>} A promise that resolves to the result when the web worker has loaded and compiled the web assembly module and is ready to process tasks.
+ * @param {object} [webAssemblyOptions] An object with the following properties:
+ * @param {string} [webAssemblyOptions.modulePath] The path of the web assembly JavaScript wrapper module.
+ * @param {string} [webAssemblyOptions.wasmBinaryFile] The path of the web assembly binary file.
+ * @param {string} [webAssemblyOptions.fallbackModulePath] The path of the fallback JavaScript module to use if web assembly is not supported.
+ * @returns {Promise<object>} A promise that resolves to the result when the web worker has loaded and compiled the web assembly module and is ready to process tasks.
  */
 TaskProcessor.prototype.initWebAssemblyModule = function (webAssemblyOptions) {
   if (!defined(this._worker)) {
@@ -339,7 +339,7 @@ TaskProcessor.prototype.initWebAssemblyModule = function (webAssemblyOptions) {
  * If this object was destroyed, it should not be used; calling any function other than
  * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
  *
- * @returns {Boolean} True if this object was destroyed; otherwise, false.
+ * @returns {boolean} True if this object was destroyed; otherwise, false.
  *
  * @see TaskProcessor#destroy
  */

package/Source/Core/TerrainData.js

@@ -41,9 +41,9 @@ Object.defineProperties(TerrainData.prototype, {
  * @function
  *
  * @param {Rectangle} rectangle The rectangle covered by this terrain data.
- * @param {Number} longitude The longitude in radians.
- * @param {Number} latitude The latitude in radians.
- * @returns {Number} The terrain height at the specified position.  If the position
+ * @param {number} longitude The longitude in radians.
+ * @param {number} latitude The latitude in radians.
+ * @returns {number} The terrain height at the specified position.  If the position
  *          is outside the rectangle, this method will extrapolate the height, which is likely to be wildly
  *          incorrect for positions far outside the rectangle.
  */
@@ -57,11 +57,11 @@ TerrainData.prototype.interpolateHeight =
  * given, the availability of the southeast child tile is returned.
  * @function
  *
- * @param {Number} thisX The tile X coordinate of this (the parent) tile.
- * @param {Number} thisY The tile Y coordinate of this (the parent) tile.
- * @param {Number} childX The tile X coordinate of the child tile to check for availability.
- * @param {Number} childY The tile Y coordinate of the child tile to check for availability.
- * @returns {Boolean} True if the child tile is available; otherwise, false.
+ * @param {number} thisX The tile X coordinate of this (the parent) tile.
+ * @param {number} thisY The tile Y coordinate of this (the parent) tile.
+ * @param {number} childX The tile X coordinate of the child tile to check for availability.
+ * @param {number} childY The tile Y coordinate of the child tile to check for availability.
+ * @returns {boolean} True if the child tile is available; otherwise, false.
  */
 TerrainData.prototype.isChildAvailable = DeveloperError.throwInstantiationError;
 
@@ -71,15 +71,15 @@ TerrainData.prototype.isChildAvailable = DeveloperError.throwInstantiationError;
  *
  * @private
  *
- * @param {Object} options Object with the following properties:
+ * @param {object} options Object with the following properties:
  * @param {TilingScheme} options.tilingScheme The tiling scheme to which this tile belongs.
- * @param {Number} options.x The X coordinate of the tile for which to create the terrain data.
- * @param {Number} options.y The Y coordinate of the tile for which to create the terrain data.
- * @param {Number} options.level The level of the tile for which to create the terrain data.
- * @param {Number} [options.exaggeration=1.0] The scale used to exaggerate the terrain.
- * @param {Number} [options.exaggerationRelativeHeight=0.0] The height relative to which terrain is exaggerated.
- * @param {Boolean} [options.throttle=true] If true, indicates that this operation will need to be retried if too many asynchronous mesh creations are already in progress.
- * @returns {Promise.<TerrainMesh>|undefined} A promise for the terrain mesh, or undefined if too many
+ * @param {number} options.x The X coordinate of the tile for which to create the terrain data.
+ * @param {number} options.y The Y coordinate of the tile for which to create the terrain data.
+ * @param {number} options.level The level of the tile for which to create the terrain data.
+ * @param {number} [options.exaggeration=1.0] The scale used to exaggerate the terrain.
+ * @param {number} [options.exaggerationRelativeHeight=0.0] The height relative to which terrain is exaggerated.
+ * @param {boolean} [options.throttle=true] If true, indicates that this operation will need to be retried if too many asynchronous mesh creations are already in progress.
+ * @returns {Promise<TerrainMesh>|undefined} A promise for the terrain mesh, or undefined if too many
  *          asynchronous mesh creations are already in progress and the operation should
  *          be retried later.
  */
@@ -90,13 +90,13 @@ TerrainData.prototype.createMesh = DeveloperError.throwInstantiationError;
  * @function
  *
  * @param {TilingScheme} tilingScheme The tiling scheme of this terrain data.
- * @param {Number} thisX The X coordinate of this tile in the tiling scheme.
- * @param {Number} thisY The Y coordinate of this tile in the tiling scheme.
- * @param {Number} thisLevel The level of this tile in the tiling scheme.
- * @param {Number} descendantX The X coordinate within the tiling scheme of the descendant tile for which we are upsampling.
- * @param {Number} descendantY The Y coordinate within the tiling scheme of the descendant tile for which we are upsampling.
- * @param {Number} descendantLevel The level within the tiling scheme of the descendant tile for which we are upsampling.
- * @returns {Promise.<TerrainData>|undefined} A promise for upsampled terrain data for the descendant tile,
+ * @param {number} thisX The X coordinate of this tile in the tiling scheme.
+ * @param {number} thisY The Y coordinate of this tile in the tiling scheme.
+ * @param {number} thisLevel The level of this tile in the tiling scheme.
+ * @param {number} descendantX The X coordinate within the tiling scheme of the descendant tile for which we are upsampling.
+ * @param {number} descendantY The Y coordinate within the tiling scheme of the descendant tile for which we are upsampling.
+ * @param {number} descendantLevel The level within the tiling scheme of the descendant tile for which we are upsampling.
+ * @returns {Promise<TerrainData>|undefined} A promise for upsampled terrain data for the descendant tile,
  *          or undefined if too many asynchronous upsample operations are in progress and the request has been
  *          deferred.
  */
@@ -109,7 +109,7 @@ TerrainData.prototype.upsample = DeveloperError.throwInstantiationError;
  * returned from a call to {@link TerrainData#upsample}.
  * @function
  *
- * @returns {Boolean} True if this instance was created by upsampling; otherwise, false.
+ * @returns {boolean} True if this instance was created by upsampling; otherwise, false.
  */
 TerrainData.prototype.wasCreatedByUpsampling =
   DeveloperError.throwInstantiationError;
@@ -117,7 +117,7 @@ TerrainData.prototype.wasCreatedByUpsampling =
 /**
  * The maximum number of asynchronous tasks used for terrain processing.
  *
- * @type {Number}
+ * @type {number}
  * @private
  */
 TerrainData.maximumAsynchronousTasks = 5;

package/Source/Core/TerrainEncoding.js

@@ -26,14 +26,14 @@ const SHIFT_LEFT_12 = Math.pow(2.0, 12.0);
  *
  * @param {Cartesian3} center The center point of the vertices.
  * @param {AxisAlignedBoundingBox} axisAlignedBoundingBox The bounds of the tile in the east-north-up coordinates at the tiles center.
- * @param {Number} minimumHeight The minimum height.
- * @param {Number} maximumHeight The maximum height.
+ * @param {number} minimumHeight The minimum height.
+ * @param {number} maximumHeight The maximum height.
  * @param {Matrix4} fromENU The east-north-up to fixed frame matrix at the center of the terrain mesh.
- * @param {Boolean} hasVertexNormals If the mesh has vertex normals.
- * @param {Boolean} [hasWebMercatorT=false] true if the terrain data includes a Web Mercator texture coordinate; otherwise, false.
- * @param {Boolean} [hasGeodeticSurfaceNormals=false] true if the terrain data includes geodetic surface normals; otherwise, false.
- * @param {Number} [exaggeration=1.0] A scalar used to exaggerate terrain.
- * @param {Number} [exaggerationRelativeHeight=0.0] The relative height from which terrain is exaggerated.
+ * @param {boolean} hasVertexNormals If the mesh has vertex normals.
+ * @param {boolean} [hasWebMercatorT=false] true if the terrain data includes a Web Mercator texture coordinate; otherwise, false.
+ * @param {boolean} [hasGeodeticSurfaceNormals=false] true if the terrain data includes geodetic surface normals; otherwise, false.
+ * @param {number} [exaggeration=1.0] A scalar used to exaggerate terrain.
+ * @param {number} [exaggerationRelativeHeight=0.0] The relative height from which terrain is exaggerated.
  *
  * @private
  */
@@ -112,13 +112,13 @@ function TerrainEncoding(
 
   /**
    * The minimum height of the tile including the skirts.
-   * @type {Number}
+   * @type {number}
    */
   this.minimumHeight = minimumHeight;
 
   /**
    * The maximum height of the tile.
-   * @type {Number}
+   * @type {number}
    */
   this.maximumHeight = maximumHeight;
 
@@ -149,19 +149,19 @@ function TerrainEncoding(
 
   /**
    * The terrain mesh contains normals.
-   * @type {Boolean}
+   * @type {boolean}
    */
   this.hasVertexNormals = hasVertexNormals;
 
   /**
    * The terrain mesh contains a vertical texture coordinate following the Web Mercator projection.
-   * @type {Boolean}
+   * @type {boolean}
    */
   this.hasWebMercatorT = defaultValue(hasWebMercatorT, false);
 
   /**
    * The terrain mesh contains geodetic surface normals, used for terrain exaggeration.
-   * @type {Boolean}
+   * @type {boolean}
    */
   this.hasGeodeticSurfaceNormals = defaultValue(
     hasGeodeticSurfaceNormals,
@@ -170,7 +170,7 @@ function TerrainEncoding(
 
   /**
    * A scalar used to exaggerate terrain.
-   * @type {Number}
+   * @type {number}
    */
   this.exaggeration = defaultValue(exaggeration, 1.0);
 
@@ -184,7 +184,7 @@ function TerrainEncoding(
 
   /**
    * The number of components in each vertex. This value can differ with different quantizations.
-   * @type {Number}
+   * @type {number}
    */
   this.stride = 0;
 

package/Source/Core/TerrainExaggeration.js

@@ -8,9 +8,9 @@ const TerrainExaggeration = {};
 /**
  * Scales a height relative to an offset.
  *
- * @param {Number} height The height.
- * @param {Number} scale A scalar used to exaggerate the terrain. If the value is 1.0 there will be no effect.
- * @param {Number} relativeHeight The height relative to which terrain is exaggerated. If the value is 0.0 terrain will be exaggerated relative to the ellipsoid surface.
+ * @param {number} height The height.
+ * @param {number} scale A scalar used to exaggerate the terrain. If the value is 1.0 there will be no effect.
+ * @param {number} relativeHeight The height relative to which terrain is exaggerated. If the value is 0.0 terrain will be exaggerated relative to the ellipsoid surface.
  */
 TerrainExaggeration.getHeight = function (height, scale, relativeHeight) {
   return (height - relativeHeight) * scale + relativeHeight;

package/Source/Core/TerrainMesh.js

@@ -13,21 +13,21 @@ import defaultValue from "./defaultValue.js";
  *                       the Cartesian position of the vertex, H is the height above the ellipsoid, and
  *                       U and V are the texture coordinates.
  * @param {Uint8Array|Uint16Array|Uint32Array} indices The indices describing how the vertices are connected to form triangles.
- * @param {Number} indexCountWithoutSkirts The index count of the mesh not including skirts.
- * @param {Number} vertexCountWithoutSkirts The vertex count of the mesh not including skirts.
- * @param {Number} minimumHeight The lowest height in the tile, in meters above the ellipsoid.
- * @param {Number} maximumHeight The highest height in the tile, in meters above the ellipsoid.
+ * @param {number} indexCountWithoutSkirts The index count of the mesh not including skirts.
+ * @param {number} vertexCountWithoutSkirts The vertex count of the mesh not including skirts.
+ * @param {number} minimumHeight The lowest height in the tile, in meters above the ellipsoid.
+ * @param {number} maximumHeight The highest height in the tile, in meters above the ellipsoid.
  * @param {BoundingSphere} boundingSphere3D A bounding sphere that completely contains the tile.
  * @param {Cartesian3} occludeePointInScaledSpace The occludee point of the tile, represented in ellipsoid-
  *                     scaled space, and used for horizon culling.  If this point is below the horizon,
  *                     the tile is considered to be entirely below the horizon.
- * @param {Number} [vertexStride=6] The number of components in each vertex.
+ * @param {number} [vertexStride=6] The number of components in each vertex.
  * @param {OrientedBoundingBox} [orientedBoundingBox] A bounding box that completely contains the tile.
  * @param {TerrainEncoding} encoding Information used to decode the mesh.
- * @param {Number[]} westIndicesSouthToNorth The indices of the vertices on the Western edge of the tile, ordered from South to North (clockwise).
- * @param {Number[]} southIndicesEastToWest The indices of the vertices on the Southern edge of the tile, ordered from East to West (clockwise).
- * @param {Number[]} eastIndicesNorthToSouth The indices of the vertices on the Eastern edge of the tile, ordered from North to South (clockwise).
- * @param {Number[]} northIndicesWestToEast The indices of the vertices on the Northern edge of the tile, ordered from West to East (clockwise).
+ * @param {number[]} westIndicesSouthToNorth The indices of the vertices on the Western edge of the tile, ordered from South to North (clockwise).
+ * @param {number[]} southIndicesEastToWest The indices of the vertices on the Southern edge of the tile, ordered from East to West (clockwise).
+ * @param {number[]} eastIndicesNorthToSouth The indices of the vertices on the Eastern edge of the tile, ordered from North to South (clockwise).
+ * @param {number[]} northIndicesWestToEast The indices of the vertices on the Northern edge of the tile, ordered from West to East (clockwise).
  *
  * @private
  */
@@ -69,7 +69,7 @@ function TerrainMesh(
    * The number of components in each vertex.  Typically this is 6 for the 6 components
    * [X, Y, Z, H, U, V], but if each vertex has additional data (such as a vertex normal), this value
    * may be higher.
-   * @type {Number}
+   * @type {number}
    */
   this.stride = defaultValue(vertexStride, 6);
 
@@ -81,25 +81,25 @@ function TerrainMesh(
 
   /**
    * The index count of the mesh not including skirts.
-   * @type {Number}
+   * @type {number}
    */
   this.indexCountWithoutSkirts = indexCountWithoutSkirts;
 
   /**
    * The vertex count of the mesh not including skirts.
-   * @type {Number}
+   * @type {number}
    */
   this.vertexCountWithoutSkirts = vertexCountWithoutSkirts;
 
   /**
    * The lowest height in the tile, in meters above the ellipsoid.
-   * @type {Number}
+   * @type {number}
    */
   this.minimumHeight = minimumHeight;
 
   /**
    * The highest height in the tile, in meters above the ellipsoid.
-   * @type {Number}
+   * @type {number}
    */
   this.maximumHeight = maximumHeight;
 
@@ -131,25 +131,25 @@ function TerrainMesh(
 
   /**
    * The indices of the vertices on the Western edge of the tile, ordered from South to North (clockwise).
-   * @type {Number[]}
+   * @type {number[]}
    */
   this.westIndicesSouthToNorth = westIndicesSouthToNorth;
 
   /**
    * The indices of the vertices on the Southern edge of the tile, ordered from East to West (clockwise).
-   * @type {Number[]}
+   * @type {number[]}
    */
   this.southIndicesEastToWest = southIndicesEastToWest;
 
   /**
    * The indices of the vertices on the Eastern edge of the tile, ordered from North to South (clockwise).
-   * @type {Number[]}
+   * @type {number[]}
    */
   this.eastIndicesNorthToSouth = eastIndicesNorthToSouth;
 
   /**
    * The indices of the vertices on the Northern edge of the tile, ordered from West to East (clockwise).
-   * @type {Number[]}
+   * @type {number[]}
    */
   this.northIndicesWestToEast = northIndicesWestToEast;
 }

package/Source/Core/TerrainProvider.js

@@ -59,7 +59,7 @@ Object.defineProperties(TerrainProvider.prototype, {
   /**
    * Gets a value indicating whether or not the provider is ready for use.
    * @memberof TerrainProvider.prototype
-   * @type {Boolean}
+   * @type {boolean}
    * @readonly
    */
   ready: {
@@ -69,7 +69,7 @@ Object.defineProperties(TerrainProvider.prototype, {
   /**
    * Gets a promise that resolves to true when the provider is ready for use.
    * @memberof TerrainProvider.prototype
-   * @type {Promise.<Boolean>}
+   * @type {Promise<boolean>}
    * @readonly
    */
   readyPromise: {
@@ -82,7 +82,7 @@ Object.defineProperties(TerrainProvider.prototype, {
    * as a reflective surface with animated waves.  This function should not be
    * called before {@link TerrainProvider#ready} returns true.
    * @memberof TerrainProvider.prototype
-   * @type {Boolean}
+   * @type {boolean}
    * @readonly
    */
   hasWaterMask: {
@@ -93,7 +93,7 @@ Object.defineProperties(TerrainProvider.prototype, {
    * Gets a value indicating whether or not the requested tiles include vertex normals.
    * This function should not be called before {@link TerrainProvider#ready} returns true.
    * @memberof TerrainProvider.prototype
-   * @type {Boolean}
+   * @type {boolean}
    * @readonly
    */
   hasVertexNormals: {
@@ -122,8 +122,8 @@ const regularGridIndicesCache = [];
  * same list of indices.  The total number of vertices must be less than or equal
  * to 65536.
  *
- * @param {Number} width The number of vertices in the regular grid in the horizontal direction.
- * @param {Number} height The number of vertices in the regular grid in the vertical direction.
+ * @param {number} width The number of vertices in the regular grid in the horizontal direction.
+ * @param {number} height The number of vertices in the regular grid in the vertical direction.
  * @returns {Uint16Array|Uint32Array} The list of indices. Uint16Array gets returned for 64KB or less and Uint32Array for 4GB or less.
  */
 TerrainProvider.getRegularGridIndices = function (width, height) {
@@ -372,7 +372,7 @@ function addSkirtIndices(edgeIndices, vertexIndex, indices, offset) {
  * {@link Globe.maximumScreenSpaceError} screen pixels and will probably go very slowly.
  * A value of 0.5 will cut the estimated level zero geometric error in half, allowing twice the
  * screen pixels between adjacent heightmap vertices and thus rendering more quickly.
- * @type {Number}
+ * @type {number}
  */
 TerrainProvider.heightmapTerrainQuality = 0.25;
 
@@ -380,9 +380,9 @@ TerrainProvider.heightmapTerrainQuality = 0.25;
  * Determines an appropriate geometric error estimate when the geometry comes from a heightmap.
  *
  * @param {Ellipsoid} ellipsoid The ellipsoid to which the terrain is attached.
- * @param {Number} tileImageWidth The width, in pixels, of the heightmap associated with a single tile.
- * @param {Number} numberOfTilesAtLevelZero The number of tiles in the horizontal direction at tile level zero.
- * @returns {Number} An estimated geometric error.
+ * @param {number} tileImageWidth The width, in pixels, of the heightmap associated with a single tile.
+ * @param {number} numberOfTilesAtLevelZero The number of tiles in the horizontal direction at tile level zero.
+ * @returns {number} An estimated geometric error.
  */
 TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap = function (
   ellipsoid,
@@ -404,12 +404,12 @@ TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap = function (
  * may optionally include a water mask and an indication of which child tiles are available.
  * @function
  *
- * @param {Number} x The X coordinate of the tile for which to request geometry.
- * @param {Number} y The Y coordinate of the tile for which to request geometry.
- * @param {Number} level The level of the tile for which to request geometry.
+ * @param {number} x The X coordinate of the tile for which to request geometry.
+ * @param {number} y The Y coordinate of the tile for which to request geometry.
+ * @param {number} level The level of the tile for which to request geometry.
  * @param {Request} [request] The request object. Intended for internal use only.
  *
- * @returns {Promise.<TerrainData>|undefined} A promise for the requested geometry.  If this method
+ * @returns {Promise<TerrainData>|undefined} A promise for the requested geometry.  If this method
  *          returns undefined instead of a promise, it is an indication that too many requests are already
  *          pending and the request will be retried later.
  */
@@ -421,8 +421,8 @@ TerrainProvider.prototype.requestTileGeometry =
  * called before {@link TerrainProvider#ready} returns true.
  * @function
  *
- * @param {Number} level The tile level for which to get the maximum geometric error.
- * @returns {Number} The maximum geometric error.
+ * @param {number} level The tile level for which to get the maximum geometric error.
+ * @returns {number} The maximum geometric error.
  */
 TerrainProvider.prototype.getLevelMaximumGeometricError =
   DeveloperError.throwInstantiationError;
@@ -431,10 +431,10 @@ TerrainProvider.prototype.getLevelMaximumGeometricError =
  * Determines whether data for a tile is available to be loaded.
  * @function
  *
- * @param {Number} x The X coordinate of the tile for which to request geometry.
- * @param {Number} y The Y coordinate of the tile for which to request geometry.
- * @param {Number} level The level of the tile for which to request geometry.
- * @returns {Boolean|undefined} Undefined if not supported by the terrain provider, otherwise true or false.
+ * @param {number} x The X coordinate of the tile for which to request geometry.
+ * @param {number} y The Y coordinate of the tile for which to request geometry.
+ * @param {number} level The level of the tile for which to request geometry.
+ * @returns {boolean|undefined} Undefined if not supported by the terrain provider, otherwise true or false.
  */
 TerrainProvider.prototype.getTileDataAvailable =
   DeveloperError.throwInstantiationError;
@@ -443,9 +443,9 @@ TerrainProvider.prototype.getTileDataAvailable =
  * Makes sure we load availability data for a tile
  * @function
  *
- * @param {Number} x The X coordinate of the tile for which to request geometry.
- * @param {Number} y The Y coordinate of the tile for which to request geometry.
- * @param {Number} level The level of the tile for which to request geometry.
+ * @param {number} x The X coordinate of the tile for which to request geometry.
+ * @param {number} y The Y coordinate of the tile for which to request geometry.
+ * @param {number} level The level of the tile for which to request geometry.
  * @returns {undefined|Promise<void>} Undefined if nothing need to be loaded or a Promise that resolves when all required tiles are loaded
  */
 TerrainProvider.prototype.loadTileDataAvailability =

package/Source/Core/TerrainQuantization.js

@@ -1,7 +1,7 @@
 /**
  * This enumerated type is used to determine how the vertices of the terrain mesh are compressed.
  *
- * @enum {Number}
+ * @enum {number}
  *
  * @private
  */
@@ -9,7 +9,7 @@ const TerrainQuantization = {
   /**
    * The vertices are not compressed.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   NONE: 0,
@@ -17,7 +17,7 @@ const TerrainQuantization = {
   /**
    * The vertices are compressed to 12 bits.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   BITS12: 1,

package/Source/Core/TileAvailability.js

@@ -10,7 +10,7 @@ import Rectangle from "./Rectangle.js";
  * @constructor
  *
  * @param {TilingScheme} tilingScheme The tiling scheme in which to report availability.
- * @param {Number} maximumLevel The maximum tile level that is potentially available.
+ * @param {number} maximumLevel The maximum tile level that is potentially available.
  */
 function TileAvailability(tilingScheme, maximumLevel) {
   this._tilingScheme = tilingScheme;
@@ -37,11 +37,11 @@ function findNode(level, x, y, nodes) {
  * Marks a rectangular range of tiles in a particular level as being available.  For best performance,
  * add your ranges in order of increasing level.
  *
- * @param {Number} level The level.
- * @param {Number} startX The X coordinate of the first available tiles at the level.
- * @param {Number} startY The Y coordinate of the first available tiles at the level.
- * @param {Number} endX The X coordinate of the last available tiles at the level.
- * @param {Number} endY The Y coordinate of the last available tiles at the level.
+ * @param {number} level The level.
+ * @param {number} startX The X coordinate of the first available tiles at the level.
+ * @param {number} startY The Y coordinate of the first available tiles at the level.
+ * @param {number} endX The X coordinate of the last available tiles at the level.
+ * @param {number} endY The Y coordinate of the last available tiles at the level.
  */
 TileAvailability.prototype.addAvailableTileRange = function (
   level,
@@ -93,7 +93,7 @@ TileAvailability.prototype.addAvailableTileRange = function (
  * {@link TileAvailability#addAvailableTileRange}.
  *
  * @param {Cartographic} position The position for which to determine the maximum available level.  The height component is ignored.
- * @return {Number} The level of the most detailed tile covering the position.
+ * @return {number} The level of the most detailed tile covering the position.
  * @throws {DeveloperError} If position is outside any tile according to the tiling scheme.
  */
 TileAvailability.prototype.computeMaximumLevelAtPosition = function (position) {
@@ -127,7 +127,7 @@ const eastScratch = new Rectangle();
  * {@link TileAvailability#addAvailableTileRange}.
  *
  * @param {Rectangle} rectangle The rectangle.
- * @return {Number} The best available level for the entire rectangle.
+ * @return {number} The best available level for the entire rectangle.
  */
 TileAvailability.prototype.computeBestAvailableLevelOverRectangle = function (
   rectangle
@@ -187,10 +187,10 @@ const cartographicScratch = new Cartographic();
 
 /**
  * Determines if a particular tile is available.
- * @param {Number} level The tile level to check.
- * @param {Number} x The X coordinate of the tile to check.
- * @param {Number} y The Y coordinate of the tile to check.
- * @return {Boolean} True if the tile is available; otherwise, false.
+ * @param {number} level The tile level to check.
+ * @param {number} x The X coordinate of the tile to check.
+ * @param {number} y The Y coordinate of the tile to check.
+ * @return {boolean} True if the tile is available; otherwise, false.
  */
 TileAvailability.prototype.isTileAvailable = function (level, x, y) {
   // Get the center of the tile and find the maximum level at that position.
@@ -220,10 +220,10 @@ TileAvailability.prototype.isTileAvailable = function (level, x, y) {
  *     <tr><td>3</td><td>8</td><td>Northeast</td></tr>
  * </table>
  *
- * @param {Number} level The level of the parent tile.
- * @param {Number} x The X coordinate of the parent tile.
- * @param {Number} y The Y coordinate of the parent tile.
- * @return {Number} The bit mask indicating child availability.
+ * @param {number} level The level of the parent tile.
+ * @param {number} x The X coordinate of the parent tile.
+ * @param {number} y The Y coordinate of the parent tile.
+ * @return {number} The bit mask indicating child availability.
  */
 TileAvailability.prototype.computeChildMaskForTile = function (level, x, y) {
   const childLevel = level + 1;