@cesium/engine 1.1.0 → 2.1.0

package/Source/Core/QuadraticRealPolynomial.js

@@ -11,10 +11,10 @@ const QuadraticRealPolynomial = {};
 /**
  * Provides the discriminant of the quadratic equation from the supplied coefficients.
  *
- * @param {Number} a The coefficient of the 2nd order monomial.
- * @param {Number} b The coefficient of the 1st order monomial.
- * @param {Number} c The coefficient of the 0th order monomial.
- * @returns {Number} The value of the discriminant.
+ * @param {number} a The coefficient of the 2nd order monomial.
+ * @param {number} b The coefficient of the 1st order monomial.
+ * @param {number} c The coefficient of the 0th order monomial.
+ * @returns {number} The value of the discriminant.
  */
 QuadraticRealPolynomial.computeDiscriminant = function (a, b, c) {
   //>>includeStart('debug', pragmas.debug);
@@ -48,10 +48,10 @@ function addWithCancellationCheck(left, right, tolerance) {
 /**
  * Provides the real valued roots of the quadratic polynomial with the provided coefficients.
  *
- * @param {Number} a The coefficient of the 2nd order monomial.
- * @param {Number} b The coefficient of the 1st order monomial.
- * @param {Number} c The coefficient of the 0th order monomial.
- * @returns {Number[]} The real valued roots.
+ * @param {number} a The coefficient of the 2nd order monomial.
+ * @param {number} b The coefficient of the 1st order monomial.
+ * @param {number} c The coefficient of the 0th order monomial.
+ * @returns {number[]} The real valued roots.
  */
 QuadraticRealPolynomial.computeRealRoots = function (a, b, c) {
   //>>includeStart('debug', pragmas.debug);

package/Source/Core/QuantizedMeshTerrainData.js

@@ -24,26 +24,26 @@ import TerrainMesh from "./TerrainMesh.js";
  * @alias QuantizedMeshTerrainData
  * @constructor
  *
- * @param {Object} options Object with the following properties:
+ * @param {object} options Object with the following properties:
  * @param {Uint16Array} options.quantizedVertices The buffer containing the quantized mesh.
  * @param {Uint16Array|Uint32Array} options.indices The indices specifying how the quantized vertices are linked
  *                      together into triangles.  Each three indices specifies one triangle.
- * @param {Number} options.minimumHeight The minimum terrain height within the tile, in meters above the ellipsoid.
- * @param {Number} options.maximumHeight The maximum terrain height within the tile, in meters above the ellipsoid.
+ * @param {number} options.minimumHeight The minimum terrain height within the tile, in meters above the ellipsoid.
+ * @param {number} options.maximumHeight The maximum terrain height within the tile, in meters above the ellipsoid.
  * @param {BoundingSphere} options.boundingSphere A sphere bounding all of the vertices in the mesh.
  * @param {OrientedBoundingBox} [options.orientedBoundingBox] An OrientedBoundingBox bounding all of the vertices in the mesh.
  * @param {Cartesian3} options.horizonOcclusionPoint The horizon occlusion point of the mesh.  If this point
  *                      is below the horizon, the entire tile is assumed to be below the horizon as well.
  *                      The point is expressed in ellipsoid-scaled coordinates.
- * @param {Number[]} options.westIndices The indices of the vertices on the western edge of the tile.
- * @param {Number[]} options.southIndices The indices of the vertices on the southern edge of the tile.
- * @param {Number[]} options.eastIndices The indices of the vertices on the eastern edge of the tile.
- * @param {Number[]} options.northIndices The indices of the vertices on the northern edge of the tile.
- * @param {Number} options.westSkirtHeight The height of the skirt to add on the western edge of the tile.
- * @param {Number} options.southSkirtHeight The height of the skirt to add on the southern edge of the tile.
- * @param {Number} options.eastSkirtHeight The height of the skirt to add on the eastern edge of the tile.
- * @param {Number} options.northSkirtHeight The height of the skirt to add on the northern edge of the tile.
- * @param {Number} [options.childTileMask=15] A bit mask indicating which of this tile's four children exist.
+ * @param {number[]} options.westIndices The indices of the vertices on the western edge of the tile.
+ * @param {number[]} options.southIndices The indices of the vertices on the southern edge of the tile.
+ * @param {number[]} options.eastIndices The indices of the vertices on the eastern edge of the tile.
+ * @param {number[]} options.northIndices The indices of the vertices on the northern edge of the tile.
+ * @param {number} options.westSkirtHeight The height of the skirt to add on the western edge of the tile.
+ * @param {number} options.southSkirtHeight The height of the skirt to add on the southern edge of the tile.
+ * @param {number} options.eastSkirtHeight The height of the skirt to add on the eastern edge of the tile.
+ * @param {number} options.northSkirtHeight The height of the skirt to add on the northern edge of the tile.
+ * @param {number} [options.childTileMask=15] A bit mask indicating which of this tile's four children exist.
  *                 If a child's bit is set, geometry will be requested for that tile as well when it
  *                 is needed.  If the bit is cleared, the child tile is not requested and geometry is
  *                 instead upsampled from the parent.  The bit values are as follows:
@@ -54,7 +54,7 @@ import TerrainMesh from "./TerrainMesh.js";
  *                  <tr><td>2</td><td>4</td><td>Northwest</td></tr>
  *                  <tr><td>3</td><td>8</td><td>Northeast</td></tr>
  *                 </table>
- * @param {Boolean} [options.createdByUpsampling=false] True if this instance was created by upsampling another instance;
+ * @param {boolean} [options.createdByUpsampling=false] True if this instance was created by upsampling another instance;
  *                  otherwise, false.
  * @param {Uint8Array} [options.encodedNormals] The buffer containing per vertex normals, encoded using 'oct' encoding
  * @param {Uint8Array} [options.waterMask] The buffer containing the watermask.
@@ -275,15 +275,15 @@ const createMeshTaskProcessorThrottle = new TaskProcessor(
  *
  * @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.
  */
@@ -418,13 +418,13 @@ const upsampleTaskProcessor = new TaskProcessor(
  * vertices in this instance, interpolated if necessary.
  *
  * @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.<QuantizedMeshTerrainData>|undefined} A promise for upsampled heightmap 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<QuantizedMeshTerrainData>|undefined} A promise for upsampled heightmap terrain data for the descendant tile,
  *          or undefined if too many asynchronous upsample operations are in progress and the request has been
  *          deferred.
  */
@@ -563,9 +563,9 @@ const barycentricCoordinateScratch = new Cartesian3();
  * Computes the terrain height at a specified longitude and latitude.
  *
  * @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.  The position is clamped to
+ * @param {number} longitude The longitude in radians.
+ * @param {number} latitude The latitude in radians.
+ * @returns {number} The terrain height at the specified position.  The position is clamped to
  *          the rectangle, so expect incorrect results for positions far outside the rectangle.
  */
 QuantizedMeshTerrainData.prototype.interpolateHeight = function (
@@ -720,11 +720,11 @@ function interpolateHeight(terrainData, u, v) {
  * to be one of the four children of this tile.  If non-child tile coordinates are
  * given, the availability of the southeast child tile is returned.
  *
- * @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.
  */
 QuantizedMeshTerrainData.prototype.isChildAvailable = function (
   thisX,
@@ -764,7 +764,7 @@ QuantizedMeshTerrainData.prototype.isChildAvailable = function (
  * as by downloading it from a remote server.  This method should return true for instances
  * returned from a call to {@link HeightmapTerrainData#upsample}.
  *
- * @returns {Boolean} True if this instance was created by upsampling; otherwise, false.
+ * @returns {boolean} True if this instance was created by upsampling; otherwise, false.
  */
 QuantizedMeshTerrainData.prototype.wasCreatedByUpsampling = function () {
   return this._createdByUpsampling;

package/Source/Core/QuarticRealPolynomial.js

@@ -13,12 +13,12 @@ const QuarticRealPolynomial = {};
 /**
  * Provides the discriminant of the quartic equation from the supplied coefficients.
  *
- * @param {Number} a The coefficient of the 4th order monomial.
- * @param {Number} b The coefficient of the 3rd order monomial.
- * @param {Number} c The coefficient of the 2nd order monomial.
- * @param {Number} d The coefficient of the 1st order monomial.
- * @param {Number} e The coefficient of the 0th order monomial.
- * @returns {Number} The value of the discriminant.
+ * @param {number} a The coefficient of the 4th order monomial.
+ * @param {number} b The coefficient of the 3rd order monomial.
+ * @param {number} c The coefficient of the 2nd order monomial.
+ * @param {number} d The coefficient of the 1st order monomial.
+ * @param {number} e The coefficient of the 0th order monomial.
+ * @returns {number} The value of the discriminant.
  */
 QuarticRealPolynomial.computeDiscriminant = function (a, b, c, d, e) {
   //>>includeStart('debug', pragmas.debug);
@@ -263,12 +263,12 @@ function neumark(a3, a2, a1, a0) {
 /**
  * Provides the real valued roots of the quartic polynomial with the provided coefficients.
  *
- * @param {Number} a The coefficient of the 4th order monomial.
- * @param {Number} b The coefficient of the 3rd order monomial.
- * @param {Number} c The coefficient of the 2nd order monomial.
- * @param {Number} d The coefficient of the 1st order monomial.
- * @param {Number} e The coefficient of the 0th order monomial.
- * @returns {Number[]} The real valued roots.
+ * @param {number} a The coefficient of the 4th order monomial.
+ * @param {number} b The coefficient of the 3rd order monomial.
+ * @param {number} c The coefficient of the 2nd order monomial.
+ * @param {number} d The coefficient of the 1st order monomial.
+ * @param {number} e The coefficient of the 0th order monomial.
+ * @returns {number[]} The real valued roots.
  */
 QuarticRealPolynomial.computeRealRoots = function (a, b, c, d, e) {
   //>>includeStart('debug', pragmas.debug);

package/Source/Core/Quaternion.js

@@ -11,38 +11,38 @@ import Matrix3 from "./Matrix3.js";
  * @alias Quaternion
  * @constructor
  *
- * @param {Number} [x=0.0] The X component.
- * @param {Number} [y=0.0] The Y component.
- * @param {Number} [z=0.0] The Z component.
- * @param {Number} [w=0.0] The W component.
+ * @param {number} [x=0.0] The X component.
+ * @param {number} [y=0.0] The Y component.
+ * @param {number} [z=0.0] The Z component.
+ * @param {number} [w=0.0] The W component.
  *
  * @see PackableForInterpolation
  */
 function Quaternion(x, y, z, w) {
   /**
    * The X component.
-   * @type {Number}
+   * @type {number}
    * @default 0.0
    */
   this.x = defaultValue(x, 0.0);
 
   /**
    * The Y component.
-   * @type {Number}
+   * @type {number}
    * @default 0.0
    */
   this.y = defaultValue(y, 0.0);
 
   /**
    * The Z component.
-   * @type {Number}
+   * @type {number}
    * @default 0.0
    */
   this.z = defaultValue(z, 0.0);
 
   /**
    * The W component.
-   * @type {Number}
+   * @type {number}
    * @default 0.0
    */
   this.w = defaultValue(w, 0.0);
@@ -54,7 +54,7 @@ let fromAxisAngleScratch = new Cartesian3();
  * Computes a quaternion representing a rotation around an axis.
  *
  * @param {Cartesian3} axis The axis of rotation.
- * @param {Number} angle The angle in radians to rotate around the axis.
+ * @param {number} angle The angle in radians to rotate around the axis.
  * @param {Quaternion} [result] The object onto which to store the result.
  * @returns {Quaternion} The modified result parameter or a new Quaternion instance if one was not provided.
  */
@@ -220,7 +220,7 @@ const sampledQuaternionQuaternion0Conjugate = new Quaternion();
 
 /**
  * The number of elements used to pack the object into an array.
- * @type {Number}
+ * @type {number}
  */
 Quaternion.packedLength = 4;
 
@@ -228,10 +228,10 @@ Quaternion.packedLength = 4;
  * Stores the provided instance into the provided array.
  *
  * @param {Quaternion} value The value to pack.
- * @param {Number[]} array The array to pack into.
- * @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.
+ * @param {number[]} array The array to pack into.
+ * @param {number} [startingIndex=0] The index into the array at which to start packing the elements.
  *
- * @returns {Number[]} The array that was packed into
+ * @returns {number[]} The array that was packed into
  */
 Quaternion.pack = function (value, array, startingIndex) {
   //>>includeStart('debug', pragmas.debug);
@@ -252,8 +252,8 @@ Quaternion.pack = function (value, array, startingIndex) {
 /**
  * Retrieves an instance from a packed array.
  *
- * @param {Number[]} array The packed array.
- * @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
+ * @param {number[]} array The packed array.
+ * @param {number} [startingIndex=0] The starting index of the element to be unpacked.
  * @param {Quaternion} [result] The object into which to store the result.
  * @returns {Quaternion} The modified result parameter or a new Quaternion instance if one was not provided.
  */
@@ -276,17 +276,17 @@ Quaternion.unpack = function (array, startingIndex, result) {
 
 /**
  * The number of elements used to store the object into an array in its interpolatable form.
- * @type {Number}
+ * @type {number}
  */
 Quaternion.packedInterpolationLength = 3;
 
 /**
  * Converts a packed array into a form suitable for interpolation.
  *
- * @param {Number[]} packedArray The packed array.
- * @param {Number} [startingIndex=0] The index of the first element to be converted.
- * @param {Number} [lastIndex=packedArray.length] The index of the last element to be converted.
- * @param {Number[]} [result] The object into which to store the result.
+ * @param {number[]} packedArray The packed array.
+ * @param {number} [startingIndex=0] The index of the first element to be converted.
+ * @param {number} [lastIndex=packedArray.length] The index of the last element to be converted.
+ * @param {number[]} [result] The object into which to store the result.
  */
 Quaternion.convertPackedArrayForInterpolation = function (
   packedArray,
@@ -342,10 +342,10 @@ Quaternion.convertPackedArrayForInterpolation = function (
 /**
  * Retrieves an instance from a packed array converted with {@link convertPackedArrayForInterpolation}.
  *
- * @param {Number[]} array The array previously packed for interpolation.
- * @param {Number[]} sourceArray The original packed array.
- * @param {Number} [firstIndex=0] The firstIndex used to convert the array.
- * @param {Number} [lastIndex=packedArray.length] The lastIndex used to convert the array.
+ * @param {number[]} array The array previously packed for interpolation.
+ * @param {number[]} sourceArray The original packed array.
+ * @param {number} [firstIndex=0] The firstIndex used to convert the array.
+ * @param {number} [lastIndex=packedArray.length] The lastIndex used to convert the array.
  * @param {Quaternion} [result] The object into which to store the result.
  * @returns {Quaternion} The modified result parameter or a new Quaternion instance if one was not provided.
  */
@@ -433,7 +433,7 @@ Quaternion.conjugate = function (quaternion, result) {
  * Computes magnitude squared for the provided quaternion.
  *
  * @param {Quaternion} quaternion The quaternion to conjugate.
- * @returns {Number} The magnitude squared.
+ * @returns {number} The magnitude squared.
  */
 Quaternion.magnitudeSquared = function (quaternion) {
   //>>includeStart('debug', pragmas.debug);
@@ -452,7 +452,7 @@ Quaternion.magnitudeSquared = function (quaternion) {
  * Computes magnitude for the provided quaternion.
  *
  * @param {Quaternion} quaternion The quaternion to conjugate.
- * @returns {Number} The magnitude.
+ * @returns {number} The magnitude.
  */
 Quaternion.magnitude = function (quaternion) {
   return Math.sqrt(Quaternion.magnitudeSquared(quaternion));
@@ -569,7 +569,7 @@ Quaternion.negate = function (quaternion, result) {
  *
  * @param {Quaternion} left The first quaternion.
  * @param {Quaternion} right The second quaternion.
- * @returns {Number} The dot product.
+ * @returns {number} The dot product.
  */
 Quaternion.dot = function (left, right) {
   //>>includeStart('debug', pragmas.debug);
@@ -623,7 +623,7 @@ Quaternion.multiply = function (left, right, result) {
  * Multiplies the provided quaternion componentwise by the provided scalar.
  *
  * @param {Quaternion} quaternion The quaternion to be scaled.
- * @param {Number} scalar The scalar to multiply with.
+ * @param {number} scalar The scalar to multiply with.
  * @param {Quaternion} result The object onto which to store the result.
  * @returns {Quaternion} The modified result parameter.
  */
@@ -645,7 +645,7 @@ Quaternion.multiplyByScalar = function (quaternion, scalar, result) {
  * Divides the provided quaternion componentwise by the provided scalar.
  *
  * @param {Quaternion} quaternion The quaternion to be divided.
- * @param {Number} scalar The scalar to divide by.
+ * @param {number} scalar The scalar to divide by.
  * @param {Quaternion} result The object onto which to store the result.
  * @returns {Quaternion} The modified result parameter.
  */
@@ -694,7 +694,7 @@ Quaternion.computeAxis = function (quaternion, result) {
  * Computes the angle of rotation of the provided quaternion.
  *
  * @param {Quaternion} quaternion The quaternion to use.
- * @returns {Number} The angle of rotation.
+ * @returns {number} The angle of rotation.
  */
 Quaternion.computeAngle = function (quaternion) {
   //>>includeStart('debug', pragmas.debug);
@@ -713,7 +713,7 @@ let lerpScratch = new Quaternion();
  *
  * @param {Quaternion} start The value corresponding to t at 0.0.
  * @param {Quaternion} end The value corresponding to t at 1.0.
- * @param {Number} t The point along t at which to interpolate.
+ * @param {number} t The point along t at which to interpolate.
  * @param {Quaternion} result The object onto which to store the result.
  * @returns {Quaternion} The modified result parameter.
  */
@@ -738,7 +738,7 @@ let slerpScaledR = new Quaternion();
  *
  * @param {Quaternion} start The value corresponding to t at 0.0.
  * @param {Quaternion} end The value corresponding to t at 1.0.
- * @param {Number} t The point along t at which to interpolate.
+ * @param {number} t The point along t at which to interpolate.
  * @param {Quaternion} result The object onto which to store the result.
  * @returns {Quaternion} The modified result parameter.
  *
@@ -881,7 +881,7 @@ Quaternion.computeInnerQuadrangle = function (q0, q1, q2, result) {
  * @param {Quaternion} q1 The second quaternion.
  * @param {Quaternion} s0 The first inner quadrangle.
  * @param {Quaternion} s1 The second inner quadrangle.
- * @param {Number} t The time in [0,1] used to interpolate.
+ * @param {number} t The time in [0,1] used to interpolate.
  * @param {Quaternion} result The object onto which to store the result.
  * @returns {Quaternion} The modified result parameter.
  *
@@ -937,7 +937,7 @@ v[7] = (opmu * 8.0) / 17.0;
  *
  * @param {Quaternion} start The value corresponding to t at 0.0.
  * @param {Quaternion} end The value corresponding to t at 1.0.
- * @param {Number} t The point along t at which to interpolate.
+ * @param {number} t The point along t at which to interpolate.
  * @param {Quaternion} result The object onto which to store the result.
  * @returns {Quaternion} The modified result parameter.
  *
@@ -1016,7 +1016,7 @@ Quaternion.fastSlerp = function (start, end, t, result) {
  * @param {Quaternion} q1 The second quaternion.
  * @param {Quaternion} s0 The first inner quadrangle.
  * @param {Quaternion} s1 The second inner quadrangle.
- * @param {Number} t The time in [0,1] used to interpolate.
+ * @param {number} t The time in [0,1] used to interpolate.
  * @param {Quaternion} result The object onto which to store the result.
  * @returns {Quaternion} The modified result parameter or a new instance if none was provided.
  *
@@ -1043,7 +1043,7 @@ Quaternion.fastSquad = function (q0, q1, s0, s1, t, result) {
  *
  * @param {Quaternion} [left] The first quaternion.
  * @param {Quaternion} [right] The second quaternion.
- * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+ * @returns {boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
  */
 Quaternion.equals = function (left, right) {
   return (
@@ -1064,8 +1064,8 @@ Quaternion.equals = function (left, right) {
  *
  * @param {Quaternion} [left] The first quaternion.
  * @param {Quaternion} [right] The second quaternion.
- * @param {Number} [epsilon=0] The epsilon to use for equality testing.
- * @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
+ * @param {number} [epsilon=0] The epsilon to use for equality testing.
+ * @returns {boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
  */
 Quaternion.equalsEpsilon = function (left, right, epsilon) {
   epsilon = defaultValue(epsilon, 0);
@@ -1112,7 +1112,7 @@ Quaternion.prototype.clone = function (result) {
  * <code>true</code> if they are equal, <code>false</code> otherwise.
  *
  * @param {Quaternion} [right] The right hand side quaternion.
- * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+ * @returns {boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
  */
 Quaternion.prototype.equals = function (right) {
   return Quaternion.equals(this, right);
@@ -1124,8 +1124,8 @@ Quaternion.prototype.equals = function (right) {
  * <code>false</code> otherwise.
  *
  * @param {Quaternion} [right] The right hand side quaternion.
- * @param {Number} [epsilon=0] The epsilon to use for equality testing.
- * @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
+ * @param {number} [epsilon=0] The epsilon to use for equality testing.
+ * @returns {boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
  */
 Quaternion.prototype.equalsEpsilon = function (right, epsilon) {
   return Quaternion.equalsEpsilon(this, right, epsilon);
@@ -1134,7 +1134,7 @@ Quaternion.prototype.equalsEpsilon = function (right, epsilon) {
 /**
  * Returns a string representing this quaternion in the format (x, y, z, w).
  *
- * @returns {String} A string representing this Quaternion.
+ * @returns {string} A string representing this Quaternion.
  */
 Quaternion.prototype.toString = function () {
   return `(${this.x}, ${this.y}, ${this.z}, ${this.w})`;

package/Source/Core/QuaternionSpline.js

@@ -33,8 +33,8 @@ function createEvaluateFunction(spline) {
  * @alias QuaternionSpline
  * @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.
+ * @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 {Quaternion[]} options.points The array of {@link Quaternion} control points.
  *
@@ -82,7 +82,7 @@ Object.defineProperties(QuaternionSpline.prototype, {
    *
    * @memberof QuaternionSpline.prototype
    *
-   * @type {Number[]}
+   * @type {number[]}
    * @readonly
    */
   times: {
@@ -111,8 +111,8 @@ Object.defineProperties(QuaternionSpline.prototype, {
  * <code>time</code> is in the interval <code>[times[i], times[i + 1]]</code>.
  * @function
  *
- * @param {Number} time The time.
- * @returns {Number} The index for the element at the start of the interval.
+ * @param {number} time The time.
+ * @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
@@ -124,8 +124,8 @@ QuaternionSpline.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.
  */
 QuaternionSpline.prototype.wrapTime = Spline.prototype.wrapTime;
 
@@ -133,15 +133,15 @@ QuaternionSpline.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.
  */
 QuaternionSpline.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 {Quaternion} [result] The object onto which to store the result.
  * @returns {Quaternion} The modified result parameter or a new instance of the point on the curve at the given time.
  *

package/Source/Core/Queue.js

@@ -16,7 +16,7 @@ Object.defineProperties(Queue.prototype, {
    *
    * @memberof Queue.prototype
    *
-   * @type {Number}
+   * @type {number}
    * @readonly
    */
   length: {
@@ -114,7 +114,7 @@ Queue.prototype.sort = function (compareFunction) {
  *
  * @param {*} a An item in the array.
  * @param {*} b An item in the array.
- * @returns {Number} Returns a negative value if <code>a</code> is less than <code>b</code>,
+ * @returns {number} Returns a negative value if <code>a</code> is less than <code>b</code>,
  *          a positive value if <code>a</code> is greater than <code>b</code>, or
  *          0 if <code>a</code> is equal to <code>b</code>.
  *

package/Source/Core/Ray.js

@@ -55,7 +55,7 @@ Ray.clone = function (ray, result) {
  * where o is the origin of the ray and d is the direction.
  *
  * @param {Ray} ray The ray.
- * @param {Number} t A scalar value.
+ * @param {number} t A scalar value.
  * @param {Cartesian3} [result] The object in which the result will be stored.
  * @returns {Cartesian3} The modified result parameter, or a new instance if none was provided.
  *