@cesium/engine 2.0.0 → 2.2.0

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.
  *

package/Source/Core/Rectangle.js

@@ -11,10 +11,10 @@ import CesiumMath from "./Math.js";
  * @alias Rectangle
  * @constructor
  *
- * @param {Number} [west=0.0] The westernmost longitude, in radians, in the range [-Pi, Pi].
- * @param {Number} [south=0.0] The southernmost latitude, in radians, in the range [-Pi/2, Pi/2].
- * @param {Number} [east=0.0] The easternmost longitude, in radians, in the range [-Pi, Pi].
- * @param {Number} [north=0.0] The northernmost latitude, in radians, in the range [-Pi/2, Pi/2].
+ * @param {number} [west=0.0] The westernmost longitude, in radians, in the range [-Pi, Pi].
+ * @param {number} [south=0.0] The southernmost latitude, in radians, in the range [-Pi/2, Pi/2].
+ * @param {number} [east=0.0] The easternmost longitude, in radians, in the range [-Pi, Pi].
+ * @param {number} [north=0.0] The northernmost latitude, in radians, in the range [-Pi/2, Pi/2].
  *
  * @see Packable
  */
@@ -22,7 +22,7 @@ function Rectangle(west, south, east, north) {
   /**
    * The westernmost longitude in radians in the range [-Pi, Pi].
    *
-   * @type {Number}
+   * @type {number}
    * @default 0.0
    */
   this.west = defaultValue(west, 0.0);
@@ -30,7 +30,7 @@ function Rectangle(west, south, east, north) {
   /**
    * The southernmost latitude in radians in the range [-Pi/2, Pi/2].
    *
-   * @type {Number}
+   * @type {number}
    * @default 0.0
    */
   this.south = defaultValue(south, 0.0);
@@ -38,7 +38,7 @@ function Rectangle(west, south, east, north) {
   /**
    * The easternmost longitude in radians in the range [-Pi, Pi].
    *
-   * @type {Number}
+   * @type {number}
    * @default 0.0
    */
   this.east = defaultValue(east, 0.0);
@@ -46,7 +46,7 @@ function Rectangle(west, south, east, north) {
   /**
    * The northernmost latitude in radians in the range [-Pi/2, Pi/2].
    *
-   * @type {Number}
+   * @type {number}
    * @default 0.0
    */
   this.north = defaultValue(north, 0.0);
@@ -56,7 +56,7 @@ Object.defineProperties(Rectangle.prototype, {
   /**
    * Gets the width of the rectangle in radians.
    * @memberof Rectangle.prototype
-   * @type {Number}
+   * @type {number}
    * @readonly
    */
   width: {
@@ -68,7 +68,7 @@ Object.defineProperties(Rectangle.prototype, {
   /**
    * Gets the height of the rectangle in radians.
    * @memberof Rectangle.prototype
-   * @type {Number}
+   * @type {number}
    * @readonly
    */
   height: {
@@ -80,7 +80,7 @@ Object.defineProperties(Rectangle.prototype, {
 
 /**
  * The number of elements used to pack the object into an array.
- * @type {Number}
+ * @type {number}
  */
 Rectangle.packedLength = 4;
 
@@ -88,10 +88,10 @@ Rectangle.packedLength = 4;
  * Stores the provided instance into the provided array.
  *
  * @param {Rectangle} 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
  */
 Rectangle.pack = function (value, array, startingIndex) {
   //>>includeStart('debug', pragmas.debug);
@@ -112,8 +112,8 @@ Rectangle.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 {Rectangle} [result] The object into which to store the result.
  * @returns {Rectangle} The modified result parameter or a new Rectangle instance if one was not provided.
  */
@@ -138,7 +138,7 @@ Rectangle.unpack = function (array, startingIndex, result) {
 /**
  * Computes the width of a rectangle in radians.
  * @param {Rectangle} rectangle The rectangle to compute the width of.
- * @returns {Number} The width.
+ * @returns {number} The width.
  */
 Rectangle.computeWidth = function (rectangle) {
   //>>includeStart('debug', pragmas.debug);
@@ -155,7 +155,7 @@ Rectangle.computeWidth = function (rectangle) {
 /**
  * Computes the height of a rectangle in radians.
  * @param {Rectangle} rectangle The rectangle to compute the height of.
- * @returns {Number} The height.
+ * @returns {number} The height.
  */
 Rectangle.computeHeight = function (rectangle) {
   //>>includeStart('debug', pragmas.debug);
@@ -167,10 +167,10 @@ Rectangle.computeHeight = function (rectangle) {
 /**
  * Creates a rectangle given the boundary longitude and latitude in degrees.
  *
- * @param {Number} [west=0.0] The westernmost longitude in degrees in the range [-180.0, 180.0].
- * @param {Number} [south=0.0] The southernmost latitude in degrees in the range [-90.0, 90.0].
- * @param {Number} [east=0.0] The easternmost longitude in degrees in the range [-180.0, 180.0].
- * @param {Number} [north=0.0] The northernmost latitude in degrees in the range [-90.0, 90.0].
+ * @param {number} [west=0.0] The westernmost longitude in degrees in the range [-180.0, 180.0].
+ * @param {number} [south=0.0] The southernmost latitude in degrees in the range [-90.0, 90.0].
+ * @param {number} [east=0.0] The easternmost longitude in degrees in the range [-180.0, 180.0].
+ * @param {number} [north=0.0] The northernmost latitude in degrees in the range [-90.0, 90.0].
  * @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
  * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
  *
@@ -198,10 +198,10 @@ Rectangle.fromDegrees = function (west, south, east, north, result) {
 /**
  * Creates a rectangle given the boundary longitude and latitude in radians.
  *
- * @param {Number} [west=0.0] The westernmost longitude in radians in the range [-Math.PI, Math.PI].
- * @param {Number} [south=0.0] The southernmost latitude in radians in the range [-Math.PI/2, Math.PI/2].
- * @param {Number} [east=0.0] The easternmost longitude in radians in the range [-Math.PI, Math.PI].
- * @param {Number} [north=0.0] The northernmost latitude in radians in the range [-Math.PI/2, Math.PI/2].
+ * @param {number} [west=0.0] The westernmost longitude in radians in the range [-Math.PI, Math.PI].
+ * @param {number} [south=0.0] The southernmost latitude in radians in the range [-Math.PI/2, Math.PI/2].
+ * @param {number} [east=0.0] The easternmost longitude in radians in the range [-Math.PI, Math.PI].
+ * @param {number} [north=0.0] The northernmost latitude in radians in the range [-Math.PI/2, Math.PI/2].
  * @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
  * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
  *
@@ -372,8 +372,8 @@ Rectangle.clone = function (rectangle, result) {
  *
  * @param {Rectangle} [left] The first Rectangle.
  * @param {Rectangle} [right] The second Rectangle.
- * @param {Number} [absoluteEpsilon=0] The absolute epsilon tolerance 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} [absoluteEpsilon=0] The absolute epsilon tolerance to use for equality testing.
+ * @returns {boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
  */
 Rectangle.equalsEpsilon = function (left, right, absoluteEpsilon) {
   absoluteEpsilon = defaultValue(absoluteEpsilon, 0);
@@ -404,7 +404,7 @@ Rectangle.prototype.clone = function (result) {
  * <code>true</code> if they are equal, <code>false</code> otherwise.
  *
  * @param {Rectangle} [other] The Rectangle to compare.
- * @returns {Boolean} <code>true</code> if the Rectangles are equal, <code>false</code> otherwise.
+ * @returns {boolean} <code>true</code> if the Rectangles are equal, <code>false</code> otherwise.
  */
 Rectangle.prototype.equals = function (other) {
   return Rectangle.equals(this, other);
@@ -416,7 +416,7 @@ Rectangle.prototype.equals = function (other) {
  *
  * @param {Rectangle} [left] The first Rectangle.
  * @param {Rectangle} [right] The second Rectangle.
- * @returns {Boolean} <code>true</code> if left and right are equal; otherwise <code>false</code>.
+ * @returns {boolean} <code>true</code> if left and right are equal; otherwise <code>false</code>.
  */
 Rectangle.equals = function (left, right) {
   return (
@@ -436,8 +436,8 @@ Rectangle.equals = function (left, right) {
  * <code>false</code> otherwise.
  *
  * @param {Rectangle} [other] The Rectangle to compare.
- * @param {Number} [epsilon=0] The epsilon to use for equality testing.
- * @returns {Boolean} <code>true</code> if the Rectangles 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 the Rectangles are within the provided epsilon, <code>false</code> otherwise.
  */
 Rectangle.prototype.equalsEpsilon = function (other, epsilon) {
   return Rectangle.equalsEpsilon(this, other, epsilon);
@@ -786,7 +786,7 @@ Rectangle.expand = function (rectangle, cartographic, result) {
  *
  * @param {Rectangle} rectangle The rectangle
  * @param {Cartographic} cartographic The cartographic to test.
- * @returns {Boolean} true if the provided cartographic is inside the rectangle, false otherwise.
+ * @returns {boolean} true if the provided cartographic is inside the rectangle, false otherwise.
  */
 Rectangle.contains = function (rectangle, cartographic) {
   //>>includeStart('debug', pragmas.debug);
@@ -824,7 +824,7 @@ const subsampleLlaScratch = new Cartographic();
  *
  * @param {Rectangle} rectangle The rectangle to subsample.
  * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid to use.
- * @param {Number} [surfaceHeight=0.0] The height of the rectangle above the ellipsoid.
+ * @param {number} [surfaceHeight=0.0] The height of the rectangle above the ellipsoid.
  * @param {Cartesian3[]} [result] The array of Cartesians onto which to store the result.
  * @returns {Cartesian3[]} The modified result parameter or a new Array of Cartesians instances if none was provided.
  */
@@ -898,10 +898,10 @@ Rectangle.subsample = function (rectangle, ellipsoid, surfaceHeight, result) {
  * Computes a subsection of a rectangle from normalized coordinates in the range [0.0, 1.0].
  *
  * @param {Rectangle} rectangle The rectangle to subsection.
- * @param {Number} westLerp The west interpolation factor in the range [0.0, 1.0]. Must be less than or equal to eastLerp.
- * @param {Number} southLerp The south interpolation factor in the range [0.0, 1.0]. Must be less than or equal to northLerp.
- * @param {Number} eastLerp The east interpolation factor in the range [0.0, 1.0]. Must be greater than or equal to westLerp.
- * @param {Number} northLerp The north interpolation factor in the range [0.0, 1.0]. Must be greater than or equal to southLerp.
+ * @param {number} westLerp The west interpolation factor in the range [0.0, 1.0]. Must be less than or equal to eastLerp.
+ * @param {number} southLerp The south interpolation factor in the range [0.0, 1.0]. Must be less than or equal to northLerp.
+ * @param {number} eastLerp The east interpolation factor in the range [0.0, 1.0]. Must be greater than or equal to westLerp.
+ * @param {number} northLerp The north interpolation factor in the range [0.0, 1.0]. Must be greater than or equal to southLerp.
  * @param {Rectangle} [result] The object onto which to store the result.
  * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
  */

package/Source/Core/RectangleCollisionChecker.js

@@ -29,7 +29,7 @@ RectangleWithId.fromRectangleAndId = function (id, rectangle, result) {
 /**
  * Insert a rectangle into the collision checker.
  *
- * @param {String} id Unique string ID for the rectangle being inserted.
+ * @param {string} id Unique string ID for the rectangle being inserted.
  * @param {Rectangle} rectangle A Rectangle
  * @private
  */
@@ -55,7 +55,7 @@ const removalScratch = new RectangleWithId();
 /**
  * Remove a rectangle from the collision checker.
  *
- * @param {String} id Unique string ID for the rectangle being removed.
+ * @param {string} id Unique string ID for the rectangle being removed.
  * @param {Rectangle} rectangle A Rectangle
  * @private
  */
@@ -78,7 +78,7 @@ const collisionScratch = new RectangleWithId();
  * Checks if a given rectangle collides with any of the rectangles in the collection.
  *
  * @param {Rectangle} rectangle A Rectangle that should be checked against the rectangles in the collision checker.
- * @returns {Boolean} Whether the rectangle collides with any of the rectangles in the collision checker.
+ * @returns {boolean} Whether the rectangle collides with any of the rectangles in the collision checker.
  */
 RectangleCollisionChecker.prototype.collides = function (rectangle) {
   //>>includeStart('debug', pragmas.debug);