@cesium/engine 10.1.0 → 11.1.0

package/Source/Core/EllipsoidalOccluder.js

@@ -70,7 +70,7 @@ Object.defineProperties(EllipsoidalOccluder.prototype, {
       const ellipsoid = this._ellipsoid;
       const cv = ellipsoid.transformPositionToScaledSpace(
         cameraPosition,
-        this._cameraPositionInScaledSpace
+        this._cameraPositionInScaledSpace,
       );
       const vhMagnitudeSquared = Cartesian3.magnitudeSquared(cv) - 1.0;
 
@@ -100,12 +100,12 @@ EllipsoidalOccluder.prototype.isPointVisible = function (occludee) {
   const ellipsoid = this._ellipsoid;
   const occludeeScaledSpacePosition = ellipsoid.transformPositionToScaledSpace(
     occludee,
-    scratchCartesian
+    scratchCartesian,
   );
   return isScaledSpacePointVisible(
     occludeeScaledSpacePosition,
     this._cameraPositionInScaledSpace,
-    this._distanceToLimbInScaledSpaceSquared
+    this._distanceToLimbInScaledSpaceSquared,
   );
 };
 
@@ -126,12 +126,12 @@ EllipsoidalOccluder.prototype.isPointVisible = function (occludee) {
  * occluder.isScaledSpacePointVisible(scaledSpacePoint); //returns true
  */
 EllipsoidalOccluder.prototype.isScaledSpacePointVisible = function (
-  occludeeScaledSpacePosition
+  occludeeScaledSpacePosition,
 ) {
   return isScaledSpacePointVisible(
     occludeeScaledSpacePosition,
     this._cameraPositionInScaledSpace,
-    this._distanceToLimbInScaledSpaceSquared
+    this._distanceToLimbInScaledSpaceSquared,
   );
 };
 
@@ -147,36 +147,34 @@ const scratchCameraPositionInScaledSpaceShrunk = new Cartesian3();
  * @param {Cartesian3} occludeeScaledSpacePosition The point to test for visibility, represented in the scaled space of the possibly-shrunk ellipsoid.
  * @returns {boolean} <code>true</code> if the occludee is visible; otherwise <code>false</code>.
  */
-EllipsoidalOccluder.prototype.isScaledSpacePointVisiblePossiblyUnderEllipsoid = function (
-  occludeeScaledSpacePosition,
-  minimumHeight
-) {
-  const ellipsoid = this._ellipsoid;
-  let vhMagnitudeSquared;
-  let cv;
-
-  if (
-    defined(minimumHeight) &&
-    minimumHeight < 0.0 &&
-    ellipsoid.minimumRadius > -minimumHeight
-  ) {
-    // This code is similar to the cameraPosition setter, but unrolled for performance because it will be called a lot.
-    cv = scratchCameraPositionInScaledSpaceShrunk;
-    cv.x = this._cameraPosition.x / (ellipsoid.radii.x + minimumHeight);
-    cv.y = this._cameraPosition.y / (ellipsoid.radii.y + minimumHeight);
-    cv.z = this._cameraPosition.z / (ellipsoid.radii.z + minimumHeight);
-    vhMagnitudeSquared = cv.x * cv.x + cv.y * cv.y + cv.z * cv.z - 1.0;
-  } else {
-    cv = this._cameraPositionInScaledSpace;
-    vhMagnitudeSquared = this._distanceToLimbInScaledSpaceSquared;
-  }
+EllipsoidalOccluder.prototype.isScaledSpacePointVisiblePossiblyUnderEllipsoid =
+  function (occludeeScaledSpacePosition, minimumHeight) {
+    const ellipsoid = this._ellipsoid;
+    let vhMagnitudeSquared;
+    let cv;
+
+    if (
+      defined(minimumHeight) &&
+      minimumHeight < 0.0 &&
+      ellipsoid.minimumRadius > -minimumHeight
+    ) {
+      // This code is similar to the cameraPosition setter, but unrolled for performance because it will be called a lot.
+      cv = scratchCameraPositionInScaledSpaceShrunk;
+      cv.x = this._cameraPosition.x / (ellipsoid.radii.x + minimumHeight);
+      cv.y = this._cameraPosition.y / (ellipsoid.radii.y + minimumHeight);
+      cv.z = this._cameraPosition.z / (ellipsoid.radii.z + minimumHeight);
+      vhMagnitudeSquared = cv.x * cv.x + cv.y * cv.y + cv.z * cv.z - 1.0;
+    } else {
+      cv = this._cameraPositionInScaledSpace;
+      vhMagnitudeSquared = this._distanceToLimbInScaledSpaceSquared;
+    }
 
-  return isScaledSpacePointVisible(
-    occludeeScaledSpacePosition,
-    cv,
-    vhMagnitudeSquared
-  );
-};
+    return isScaledSpacePointVisible(
+      occludeeScaledSpacePosition,
+      cv,
+      vhMagnitudeSquared,
+    );
+  };
 
 /**
  * Computes a point that can be used for horizon culling from a list of positions.  If the point is below
@@ -197,13 +195,13 @@ EllipsoidalOccluder.prototype.isScaledSpacePointVisiblePossiblyUnderEllipsoid =
 EllipsoidalOccluder.prototype.computeHorizonCullingPoint = function (
   directionToPoint,
   positions,
-  result
+  result,
 ) {
   return computeHorizonCullingPointFromPositions(
     this._ellipsoid,
     directionToPoint,
     positions,
-    result
+    result,
   );
 };
 
@@ -226,24 +224,20 @@ const scratchEllipsoidShrunk = Ellipsoid.clone(Ellipsoid.UNIT_SPHERE);
  * @param {Cartesian3} [result] The instance on which to store the result instead of allocating a new instance.
  * @returns {Cartesian3} The computed horizon culling point, expressed in the possibly-shrunk ellipsoid-scaled space.
  */
-EllipsoidalOccluder.prototype.computeHorizonCullingPointPossiblyUnderEllipsoid = function (
-  directionToPoint,
-  positions,
-  minimumHeight,
-  result
-) {
-  const possiblyShrunkEllipsoid = getPossiblyShrunkEllipsoid(
-    this._ellipsoid,
-    minimumHeight,
-    scratchEllipsoidShrunk
-  );
-  return computeHorizonCullingPointFromPositions(
-    possiblyShrunkEllipsoid,
-    directionToPoint,
-    positions,
-    result
-  );
-};
+EllipsoidalOccluder.prototype.computeHorizonCullingPointPossiblyUnderEllipsoid =
+  function (directionToPoint, positions, minimumHeight, result) {
+    const possiblyShrunkEllipsoid = getPossiblyShrunkEllipsoid(
+      this._ellipsoid,
+      minimumHeight,
+      scratchEllipsoidShrunk,
+    );
+    return computeHorizonCullingPointFromPositions(
+      possiblyShrunkEllipsoid,
+      directionToPoint,
+      positions,
+      result,
+    );
+  };
 /**
  * Computes a point that can be used for horizon culling from a list of positions.  If the point is below
  * the horizon, all of the positions are guaranteed to be below the horizon as well.  The returned point
@@ -262,22 +256,17 @@ EllipsoidalOccluder.prototype.computeHorizonCullingPointPossiblyUnderEllipsoid =
  * @param {Cartesian3} [result] The instance on which to store the result instead of allocating a new instance.
  * @returns {Cartesian3} The computed horizon culling point, expressed in the ellipsoid-scaled space.
  */
-EllipsoidalOccluder.prototype.computeHorizonCullingPointFromVertices = function (
-  directionToPoint,
-  vertices,
-  stride,
-  center,
-  result
-) {
-  return computeHorizonCullingPointFromVertices(
-    this._ellipsoid,
-    directionToPoint,
-    vertices,
-    stride,
-    center,
-    result
-  );
-};
+EllipsoidalOccluder.prototype.computeHorizonCullingPointFromVertices =
+  function (directionToPoint, vertices, stride, center, result) {
+    return computeHorizonCullingPointFromVertices(
+      this._ellipsoid,
+      directionToPoint,
+      vertices,
+      stride,
+      center,
+      result,
+    );
+  };
 
 /**
  * Similar to {@link EllipsoidalOccluder#computeHorizonCullingPointFromVertices} except computes the culling
@@ -298,28 +287,22 @@ EllipsoidalOccluder.prototype.computeHorizonCullingPointFromVertices = function
  * @param {Cartesian3} [result] The instance on which to store the result instead of allocating a new instance.
  * @returns {Cartesian3} The computed horizon culling point, expressed in the possibly-shrunk ellipsoid-scaled space.
  */
-EllipsoidalOccluder.prototype.computeHorizonCullingPointFromVerticesPossiblyUnderEllipsoid = function (
-  directionToPoint,
-  vertices,
-  stride,
-  center,
-  minimumHeight,
-  result
-) {
-  const possiblyShrunkEllipsoid = getPossiblyShrunkEllipsoid(
-    this._ellipsoid,
-    minimumHeight,
-    scratchEllipsoidShrunk
-  );
-  return computeHorizonCullingPointFromVertices(
-    possiblyShrunkEllipsoid,
-    directionToPoint,
-    vertices,
-    stride,
-    center,
-    result
-  );
-};
+EllipsoidalOccluder.prototype.computeHorizonCullingPointFromVerticesPossiblyUnderEllipsoid =
+  function (directionToPoint, vertices, stride, center, minimumHeight, result) {
+    const possiblyShrunkEllipsoid = getPossiblyShrunkEllipsoid(
+      this._ellipsoid,
+      minimumHeight,
+      scratchEllipsoidShrunk,
+    );
+    return computeHorizonCullingPointFromVertices(
+      possiblyShrunkEllipsoid,
+      directionToPoint,
+      vertices,
+      stride,
+      center,
+      result,
+    );
+  };
 
 const subsampleScratch = [];
 
@@ -335,31 +318,28 @@ const subsampleScratch = [];
  * @param {Cartesian3} [result] The instance on which to store the result instead of allocating a new instance.
  * @returns {Cartesian3} The computed horizon culling point, expressed in the ellipsoid-scaled space.
  */
-EllipsoidalOccluder.prototype.computeHorizonCullingPointFromRectangle = function (
-  rectangle,
-  ellipsoid,
-  result
-) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("rectangle", rectangle);
-  //>>includeEnd('debug');
-
-  const positions = Rectangle.subsample(
-    rectangle,
-    ellipsoid,
-    0.0,
-    subsampleScratch
-  );
-  const bs = BoundingSphere.fromPoints(positions);
+EllipsoidalOccluder.prototype.computeHorizonCullingPointFromRectangle =
+  function (rectangle, ellipsoid, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.object("rectangle", rectangle);
+    //>>includeEnd('debug');
+
+    const positions = Rectangle.subsample(
+      rectangle,
+      ellipsoid,
+      0.0,
+      subsampleScratch,
+    );
+    const bs = BoundingSphere.fromPoints(positions);
 
-  // If the bounding sphere center is too close to the center of the occluder, it doesn't make
-  // sense to try to horizon cull it.
-  if (Cartesian3.magnitude(bs.center) < 0.1 * ellipsoid.minimumRadius) {
-    return undefined;
-  }
+    // If the bounding sphere center is too close to the center of the occluder, it doesn't make
+    // sense to try to horizon cull it.
+    if (Cartesian3.magnitude(bs.center) < 0.1 * ellipsoid.minimumRadius) {
+      return undefined;
+    }
 
-  return this.computeHorizonCullingPoint(bs.center, positions, result);
-};
+    return this.computeHorizonCullingPoint(bs.center, positions, result);
+  };
 
 const scratchEllipsoidShrunkRadii = new Cartesian3();
 
@@ -373,7 +353,7 @@ function getPossiblyShrunkEllipsoid(ellipsoid, minimumHeight, result) {
       ellipsoid.radii.x + minimumHeight,
       ellipsoid.radii.y + minimumHeight,
       ellipsoid.radii.z + minimumHeight,
-      scratchEllipsoidShrunkRadii
+      scratchEllipsoidShrunkRadii,
     );
     ellipsoid = Ellipsoid.fromCartesian3(ellipsoidShrunkRadii, result);
   }
@@ -384,7 +364,7 @@ function computeHorizonCullingPointFromPositions(
   ellipsoid,
   directionToPoint,
   positions,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("directionToPoint", directionToPoint);
@@ -397,7 +377,7 @@ function computeHorizonCullingPointFromPositions(
 
   const scaledSpaceDirectionToPoint = computeScaledSpaceDirectionToPoint(
     ellipsoid,
-    directionToPoint
+    directionToPoint,
   );
   let resultMagnitude = 0.0;
 
@@ -406,7 +386,7 @@ function computeHorizonCullingPointFromPositions(
     const candidateMagnitude = computeMagnitude(
       ellipsoid,
       position,
-      scaledSpaceDirectionToPoint
+      scaledSpaceDirectionToPoint,
     );
     if (candidateMagnitude < 0.0) {
       // all points should face the same direction, but this one doesn't, so return undefined
@@ -426,7 +406,7 @@ function computeHorizonCullingPointFromVertices(
   vertices,
   stride,
   center,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("directionToPoint", directionToPoint);
@@ -442,7 +422,7 @@ function computeHorizonCullingPointFromVertices(
   center = defaultValue(center, Cartesian3.ZERO);
   const scaledSpaceDirectionToPoint = computeScaledSpaceDirectionToPoint(
     ellipsoid,
-    directionToPoint
+    directionToPoint,
   );
   let resultMagnitude = 0.0;
 
@@ -454,7 +434,7 @@ function computeHorizonCullingPointFromVertices(
     const candidateMagnitude = computeMagnitude(
       ellipsoid,
       positionScratch,
-      scaledSpaceDirectionToPoint
+      scaledSpaceDirectionToPoint,
     );
     if (candidateMagnitude < 0.0) {
       // all points should face the same direction, but this one doesn't, so return undefined
@@ -469,7 +449,7 @@ function computeHorizonCullingPointFromVertices(
 function isScaledSpacePointVisible(
   occludeeScaledSpacePosition,
   cameraPositionInScaledSpace,
-  distanceToLimbInScaledSpaceSquared
+  distanceToLimbInScaledSpaceSquared,
 ) {
   // See https://cesium.com/blog/2013/04/25/Horizon-culling/
   const cv = cameraPositionInScaledSpace;
@@ -477,7 +457,7 @@ function isScaledSpacePointVisible(
   const vt = Cartesian3.subtract(
     occludeeScaledSpacePosition,
     cv,
-    scratchCartesian
+    scratchCartesian,
   );
   const vtDotVc = -Cartesian3.dot(vt, cv);
   // If vhMagnitudeSquared < 0 then we are below the surface of the ellipsoid and
@@ -497,14 +477,14 @@ const directionScratch = new Cartesian3();
 function computeMagnitude(ellipsoid, position, scaledSpaceDirectionToPoint) {
   const scaledSpacePosition = ellipsoid.transformPositionToScaledSpace(
     position,
-    scaledSpaceScratch
+    scaledSpaceScratch,
   );
   let magnitudeSquared = Cartesian3.magnitudeSquared(scaledSpacePosition);
   let magnitude = Math.sqrt(magnitudeSquared);
   const direction = Cartesian3.divideByScalar(
     scaledSpacePosition,
     magnitude,
-    directionScratch
+    directionScratch,
   );
 
   // For the purpose of this computation, points below the ellipsoid are consider to be on it instead.
@@ -513,7 +493,7 @@ function computeMagnitude(ellipsoid, position, scaledSpaceDirectionToPoint) {
 
   const cosAlpha = Cartesian3.dot(direction, scaledSpaceDirectionToPoint);
   const sinAlpha = Cartesian3.magnitude(
-    Cartesian3.cross(direction, scaledSpaceDirectionToPoint, direction)
+    Cartesian3.cross(direction, scaledSpaceDirectionToPoint, direction),
   );
   const cosBeta = 1.0 / magnitude;
   const sinBeta = Math.sqrt(magnitudeSquared - 1.0) * cosBeta;
@@ -524,7 +504,7 @@ function computeMagnitude(ellipsoid, position, scaledSpaceDirectionToPoint) {
 function magnitudeToPoint(
   scaledSpaceDirectionToPoint,
   resultMagnitude,
-  result
+  result,
 ) {
   // The horizon culling point is undefined if there were no positions from which to compute it,
   // the directionToPoint is pointing opposite all of the positions,  or if we computed NaN or infinity.
@@ -539,7 +519,7 @@ function magnitudeToPoint(
   return Cartesian3.multiplyByScalar(
     scaledSpaceDirectionToPoint,
     resultMagnitude,
-    result
+    result,
   );
 }
 
@@ -552,7 +532,7 @@ function computeScaledSpaceDirectionToPoint(ellipsoid, directionToPoint) {
 
   ellipsoid.transformPositionToScaledSpace(
     directionToPoint,
-    directionToPointScratch
+    directionToPointScratch,
   );
   return Cartesian3.normalize(directionToPointScratch, directionToPointScratch);
 }

package/Source/Core/FeatureDetection.js

@@ -104,7 +104,7 @@ function isInternetExplorer() {
       }
     } else if (theNavigator.appName === "Netscape") {
       fields = /Trident\/.*rv:([0-9]{1,}[\.0-9]{0,})/.exec(
-        theNavigator.userAgent
+        theNavigator.userAgent,
       );
       if (fields !== null) {
         isInternetExplorerResult = true;
@@ -200,7 +200,7 @@ function supportsImageRenderingPixelated() {
     const canvas = document.createElement("canvas");
     canvas.setAttribute(
       "style",
-      "image-rendering: -moz-crisp-edges;" + "image-rendering: pixelated;"
+      "image-rendering: -moz-crisp-edges;" + "image-rendering: pixelated;",
     );
     //canvas.style.imageRendering will be undefined, null or an empty string on unsupported browsers.
     const tmp = canvas.style.imageRendering;
@@ -222,7 +222,7 @@ function supportsWebP() {
   //>>includeStart('debug', pragmas.debug);
   if (!supportsWebP.initialized) {
     throw new DeveloperError(
-      "You must call FeatureDetection.supportsWebP.initialize and wait for the promise to resolve before calling FeatureDetection.supportsWebP"
+      "You must call FeatureDetection.supportsWebP.initialize and wait for the promise to resolve before calling FeatureDetection.supportsWebP",
     );
   }
   //>>includeEnd('debug');
@@ -271,7 +271,7 @@ if (typeof ArrayBuffer !== "undefined") {
     Int32Array,
     Uint32Array,
     Float32Array,
-    Float64Array
+    Float64Array,
   );
 
   if (typeof Uint8ClampedArray !== "undefined") {

package/Source/Core/FrustumGeometry.js

@@ -147,14 +147,14 @@ FrustumGeometry.unpack = function (array, startingIndex, result) {
     frustum = PerspectiveFrustum.unpack(
       array,
       startingIndex,
-      scratchPackPerspective
+      scratchPackPerspective,
     );
     startingIndex += PerspectiveFrustum.packedLength;
   } else {
     frustum = OrthographicFrustum.unpack(
       array,
       startingIndex,
-      scratchPackOrthographic
+      scratchPackOrthographic,
     );
     startingIndex += OrthographicFrustum.packedLength;
   }
@@ -164,13 +164,13 @@ FrustumGeometry.unpack = function (array, startingIndex, result) {
   const orientation = Quaternion.unpack(
     array,
     startingIndex,
-    scratchPackQuaternion
+    scratchPackQuaternion,
   );
   startingIndex += Quaternion.packedLength;
   const vertexFormat = VertexFormat.unpack(
     array,
     startingIndex,
-    scratchVertexFormat
+    scratchVertexFormat,
   );
   startingIndex += VertexFormat.packedLength;
   const drawNearPlane = array[startingIndex] === 1.0;
@@ -206,7 +206,7 @@ function getAttributes(
   st,
   normal,
   tangent,
-  bitangent
+  bitangent,
 ) {
   const stOffset = (offset / 3) * 2;
 
@@ -271,11 +271,11 @@ FrustumGeometry._computeNearFarPlanes = function (
   positions,
   xDirection,
   yDirection,
-  zDirection
+  zDirection,
 ) {
   const rotationMatrix = Matrix3.fromQuaternion(
     orientation,
-    scratchRotationMatrix
+    scratchRotationMatrix,
   );
   let x = defaultValue(xDirection, scratchXDirection);
   let y = defaultValue(yDirection, scratchYDirection);
@@ -300,11 +300,11 @@ FrustumGeometry._computeNearFarPlanes = function (
     const viewProjection = Matrix4.multiply(
       projection,
       view,
-      scratchInverseMatrix
+      scratchInverseMatrix,
     );
     inverseViewProjection = Matrix4.inverse(
       viewProjection,
-      scratchInverseMatrix
+      scratchInverseMatrix,
     );
   } else {
     inverseView = Matrix4.inverseTransformation(view, scratchInverseMatrix);
@@ -323,7 +323,7 @@ FrustumGeometry._computeNearFarPlanes = function (
     for (let j = 0; j < 4; ++j) {
       let corner = Cartesian4.clone(
         frustumCornersNDC[j],
-        scratchFrustumCorners[j]
+        scratchFrustumCorners[j],
       );
 
       if (!defined(inverseViewProjection)) {
@@ -353,7 +353,7 @@ FrustumGeometry._computeNearFarPlanes = function (
         corner = Matrix4.multiplyByVector(
           inverseViewProjection,
           corner,
-          corner
+          corner,
         );
 
         // Reverse perspective divide
@@ -396,7 +396,7 @@ FrustumGeometry.createGeometry = function (frustumGeometry) {
     orientation,
     frustumType,
     frustum,
-    positions
+    positions,
   );
 
   // -x plane
@@ -513,7 +513,7 @@ FrustumGeometry.createGeometry = function (frustumGeometry) {
       st,
       negativeX,
       negativeZ,
-      y
+      y,
     ); // -x
     offset += 3 * 4;
     getAttributes(
@@ -524,7 +524,7 @@ FrustumGeometry.createGeometry = function (frustumGeometry) {
       st,
       negativeY,
       negativeZ,
-      negativeX
+      negativeX,
     ); // -y
     offset += 3 * 4;
     getAttributes(offset, normals, tangents, bitangents, st, x, z, y); // +x

package/Source/Core/FrustumOutlineGeometry.js

@@ -134,14 +134,14 @@ FrustumOutlineGeometry.unpack = function (array, startingIndex, result) {
     frustum = PerspectiveFrustum.unpack(
       array,
       startingIndex,
-      scratchPackPerspective
+      scratchPackPerspective,
     );
     startingIndex += PerspectiveFrustum.packedLength;
   } else {
     frustum = OrthographicFrustum.unpack(
       array,
       startingIndex,
-      scratchPackOrthographic
+      scratchPackOrthographic,
     );
     startingIndex += OrthographicFrustum.packedLength;
   }
@@ -151,7 +151,7 @@ FrustumOutlineGeometry.unpack = function (array, startingIndex, result) {
   const orientation = Quaternion.unpack(
     array,
     startingIndex,
-    scratchPackQuaternion
+    scratchPackQuaternion,
   );
   startingIndex += Quaternion.packedLength;
   const drawNearPlane = array[startingIndex] === 1.0;
@@ -196,7 +196,7 @@ FrustumOutlineGeometry.createGeometry = function (frustumGeometry) {
     orientation,
     frustumType,
     frustum,
-    positions
+    positions,
   );
 
   const attributes = new GeometryAttributes({

package/Source/Core/GeographicTilingScheme.js

@@ -32,11 +32,11 @@ function GeographicTilingScheme(options) {
   this._projection = new GeographicProjection(this._ellipsoid);
   this._numberOfLevelZeroTilesX = defaultValue(
     options.numberOfLevelZeroTilesX,
-    2
+    2,
   );
   this._numberOfLevelZeroTilesY = defaultValue(
     options.numberOfLevelZeroTilesY,
-    1
+    1,
   );
 }
 
@@ -107,7 +107,7 @@ GeographicTilingScheme.prototype.getNumberOfYTilesAtLevel = function (level) {
  */
 GeographicTilingScheme.prototype.rectangleToNativeRectangle = function (
   rectangle,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.defined("rectangle", rectangle);
@@ -145,7 +145,7 @@ GeographicTilingScheme.prototype.tileXYToNativeRectangle = function (
   x,
   y,
   level,
-  result
+  result,
 ) {
   const rectangleRadians = this.tileXYToRectangle(x, y, level, result);
   rectangleRadians.west = CesiumMath.toDegrees(rectangleRadians.west);
@@ -170,7 +170,7 @@ GeographicTilingScheme.prototype.tileXYToRectangle = function (
   x,
   y,
   level,
-  result
+  result,
 ) {
   const rectangle = this._rectangle;
 
@@ -210,7 +210,7 @@ GeographicTilingScheme.prototype.tileXYToRectangle = function (
 GeographicTilingScheme.prototype.positionToTileXY = function (
   position,
   level,
-  result
+  result,
 ) {
   const rectangle = this._rectangle;
   if (!Rectangle.contains(rectangle, position)) {