@cesium/engine 11.0.0 → 12.0.0

package/Source/Workers/combineGeometry.js

@@ -2,13 +2,12 @@ import PrimitivePipeline from "../Scene/PrimitivePipeline.js";
 import createTaskProcessorWorker from "./createTaskProcessorWorker.js";
 
 function combineGeometry(packedParameters, transferableObjects) {
-  const parameters = PrimitivePipeline.unpackCombineGeometryParameters(
-    packedParameters
-  );
+  const parameters =
+    PrimitivePipeline.unpackCombineGeometryParameters(packedParameters);
   const results = PrimitivePipeline.combineGeometry(parameters);
   return PrimitivePipeline.packCombineGeometryResults(
     results,
-    transferableObjects
+    transferableObjects,
   );
 }
 export default createTaskProcessorWorker(combineGeometry);

package/Source/Workers/createCircleGeometry.js

@@ -8,10 +8,10 @@ function createCircleGeometry(circleGeometry, offset) {
     circleGeometry = CircleGeometry.unpack(circleGeometry, offset);
   }
   circleGeometry._ellipseGeometry._center = Cartesian3.clone(
-    circleGeometry._ellipseGeometry._center
+    circleGeometry._ellipseGeometry._center,
   );
   circleGeometry._ellipseGeometry._ellipsoid = Ellipsoid.clone(
-    circleGeometry._ellipseGeometry._ellipsoid
+    circleGeometry._ellipseGeometry._ellipsoid,
   );
   return CircleGeometry.createGeometry(circleGeometry);
 }

package/Source/Workers/createCircleOutlineGeometry.js

@@ -8,10 +8,10 @@ function createCircleOutlineGeometry(circleGeometry, offset) {
     circleGeometry = CircleOutlineGeometry.unpack(circleGeometry, offset);
   }
   circleGeometry._ellipseGeometry._center = Cartesian3.clone(
-    circleGeometry._ellipseGeometry._center
+    circleGeometry._ellipseGeometry._center,
   );
   circleGeometry._ellipseGeometry._ellipsoid = Ellipsoid.clone(
-    circleGeometry._ellipseGeometry._ellipsoid
+    circleGeometry._ellipseGeometry._ellipsoid,
   );
   return CircleOutlineGeometry.createGeometry(circleGeometry);
 }

package/Source/Workers/createCoplanarPolygonOutlineGeometry.js

@@ -6,7 +6,7 @@ function createCoplanarPolygonOutlineGeometry(polygonGeometry, offset) {
   if (defined(offset)) {
     polygonGeometry = CoplanarPolygonOutlineGeometry.unpack(
       polygonGeometry,
-      offset
+      offset,
     );
   }
   polygonGeometry._ellipsoid = Ellipsoid.clone(polygonGeometry._ellipsoid);

package/Source/Workers/createCorridorOutlineGeometry.js

@@ -6,11 +6,11 @@ function createCorridorOutlineGeometry(corridorOutlineGeometry, offset) {
   if (defined(offset)) {
     corridorOutlineGeometry = CorridorOutlineGeometry.unpack(
       corridorOutlineGeometry,
-      offset
+      offset,
     );
   }
   corridorOutlineGeometry._ellipsoid = Ellipsoid.clone(
-    corridorOutlineGeometry._ellipsoid
+    corridorOutlineGeometry._ellipsoid,
   );
   return CorridorOutlineGeometry.createGeometry(corridorOutlineGeometry);
 }

package/Source/Workers/createEllipsoidOutlineGeometry.js

@@ -5,7 +5,7 @@ function createEllipsoidOutlineGeometry(ellipsoidGeometry, offset) {
   if (defined(ellipsoidGeometry.buffer, offset)) {
     ellipsoidGeometry = EllipsoidOutlineGeometry.unpack(
       ellipsoidGeometry,
-      offset
+      offset,
     );
   }
   return EllipsoidOutlineGeometry.createGeometry(ellipsoidGeometry);

package/Source/Workers/createGeometry.js

@@ -60,10 +60,9 @@ async function createGeometry(parameters, transferableObjects) {
     }
 
     if (defined(moduleName) || defined(modulePath)) {
-      resultsOrPromises[i] = getModule(
-        moduleName,
-        modulePath
-      ).then((createFunction) => createFunction(geometry, task.offset));
+      resultsOrPromises[i] = getModule(moduleName, modulePath).then(
+        (createFunction) => createFunction(geometry, task.offset),
+      );
     } else {
       // Already created geometry
       resultsOrPromises[i] = geometry;
@@ -73,7 +72,7 @@ async function createGeometry(parameters, transferableObjects) {
   return Promise.all(resultsOrPromises).then(function (results) {
     return PrimitivePipeline.packCreateGeometryResults(
       results,
-      transferableObjects
+      transferableObjects,
     );
   });
 }

package/Source/Workers/createGroundPolylineGeometry.js

@@ -7,7 +7,7 @@ function createGroundPolylineGeometry(groundPolylineGeometry, offset) {
     if (defined(offset)) {
       groundPolylineGeometry = GroundPolylineGeometry.unpack(
         groundPolylineGeometry,
-        offset
+        offset,
       );
     }
     return GroundPolylineGeometry.createGeometry(groundPolylineGeometry);

package/Source/Workers/createPolylineVolumeGeometry.js

@@ -6,11 +6,11 @@ function createPolylineVolumeGeometry(polylineVolumeGeometry, offset) {
   if (defined(offset)) {
     polylineVolumeGeometry = PolylineVolumeGeometry.unpack(
       polylineVolumeGeometry,
-      offset
+      offset,
     );
   }
   polylineVolumeGeometry._ellipsoid = Ellipsoid.clone(
-    polylineVolumeGeometry._ellipsoid
+    polylineVolumeGeometry._ellipsoid,
   );
   return PolylineVolumeGeometry.createGeometry(polylineVolumeGeometry);
 }

package/Source/Workers/createPolylineVolumeOutlineGeometry.js

@@ -4,19 +4,19 @@ import PolylineVolumeOutlineGeometry from "../Core/PolylineVolumeOutlineGeometry
 
 function createPolylineVolumeOutlineGeometry(
   polylineVolumeOutlineGeometry,
-  offset
+  offset,
 ) {
   if (defined(offset)) {
     polylineVolumeOutlineGeometry = PolylineVolumeOutlineGeometry.unpack(
       polylineVolumeOutlineGeometry,
-      offset
+      offset,
     );
   }
   polylineVolumeOutlineGeometry._ellipsoid = Ellipsoid.clone(
-    polylineVolumeOutlineGeometry._ellipsoid
+    polylineVolumeOutlineGeometry._ellipsoid,
   );
   return PolylineVolumeOutlineGeometry.createGeometry(
-    polylineVolumeOutlineGeometry
+    polylineVolumeOutlineGeometry,
   );
 }
 export default createPolylineVolumeOutlineGeometry;

package/Source/Workers/createRectangleOutlineGeometry.js

@@ -7,7 +7,7 @@ function createRectangleOutlineGeometry(rectangleGeometry, offset) {
   if (defined(offset)) {
     rectangleGeometry = RectangleOutlineGeometry.unpack(
       rectangleGeometry,
-      offset
+      offset,
     );
   }
   rectangleGeometry._ellipsoid = Ellipsoid.clone(rectangleGeometry._ellipsoid);

package/Source/Workers/createSimplePolylineGeometry.js

@@ -6,11 +6,11 @@ function createSimplePolylineGeometry(simplePolylineGeometry, offset) {
   if (defined(offset)) {
     simplePolylineGeometry = SimplePolylineGeometry.unpack(
       simplePolylineGeometry,
-      offset
+      offset,
     );
   }
   simplePolylineGeometry._ellipsoid = Ellipsoid.clone(
-    simplePolylineGeometry._ellipsoid
+    simplePolylineGeometry._ellipsoid,
   );
   return SimplePolylineGeometry.createGeometry(simplePolylineGeometry);
 }

package/Source/Workers/createTaskProcessorWorker.js

@@ -62,7 +62,7 @@ function createTaskProcessorWorker(workerFunction) {
       // error that we can be sure will be cloneable
       responseMessage.result = undefined;
       responseMessage.error = `postMessage failed with error: ${formatError(
-        error
+        error,
       )}\n  with responseMessage: ${JSON.stringify(responseMessage)}`;
       postMessage(responseMessage);
     }

package/Source/Workers/createVectorTileClampedPolylines.js

@@ -21,7 +21,7 @@ function decodePositions(
   rectangle,
   minimumHeight,
   maximumHeight,
-  ellipsoid
+  ellipsoid,
 ) {
   const positionsLength = uBuffer.length;
   const decodedPositions = new Float64Array(positionsLength * 3);
@@ -34,7 +34,7 @@ function decodePositions(
     const lat = CesiumMath.lerp(
       rectangle.south,
       rectangle.north,
-      v / MAX_SHORT
+      v / MAX_SHORT,
     );
     const alt = CesiumMath.lerp(minimumHeight, maximumHeight, h / MAX_SHORT);
 
@@ -42,11 +42,11 @@ function decodePositions(
       lon,
       lat,
       alt,
-      scratchBVCartographic
+      scratchBVCartographic,
     );
     const decodedPosition = ellipsoid.cartographicToCartesian(
       cartographic,
-      scratchEncodedPosition
+      scratchEncodedPosition,
     );
     Cartesian3.pack(decodedPosition, decodedPositions, i * 3);
   }
@@ -134,17 +134,17 @@ function computeMiteredNormal(
   position,
   nextPosition,
   ellipsoidSurfaceNormal,
-  result
+  result,
 ) {
   const towardNext = Cartesian3.subtract(
     nextPosition,
     position,
-    towardNextScratch
+    towardNextScratch,
   );
   let towardCurr = Cartesian3.subtract(
     position,
     previousPosition,
-    towardCurrScratch
+    towardCurrScratch,
   );
   Cartesian3.normalize(towardNext, towardNext);
   Cartesian3.normalize(towardCurr, towardCurr);
@@ -153,7 +153,7 @@ function computeMiteredNormal(
     towardCurr = Cartesian3.multiplyByScalar(
       towardCurr,
       -1.0,
-      towardCurrScratch
+      towardCurrScratch,
     );
   }
 
@@ -233,17 +233,17 @@ VertexAttributesAndIndices.prototype.addVolume = function (
   halfWidth,
   batchId,
   center,
-  ellipsoid
+  ellipsoid,
 ) {
   let position = Cartesian3.add(startRTC, center, positionScratch);
   const startEllipsoidNormal = ellipsoid.geodeticSurfaceNormal(
     position,
-    scratchStartEllipsoidNormal
+    scratchStartEllipsoidNormal,
   );
   position = Cartesian3.add(endRTC, center, positionScratch);
   const endEllipsoidNormal = ellipsoid.geodeticSurfaceNormal(
     position,
-    scratchEndEllipsoidNormal
+    scratchEndEllipsoidNormal,
   );
 
   const startFaceNormal = computeMiteredNormal(
@@ -251,21 +251,21 @@ VertexAttributesAndIndices.prototype.addVolume = function (
     startRTC,
     endRTC,
     startEllipsoidNormal,
-    scratchStartFaceNormal
+    scratchStartFaceNormal,
   );
   const endFaceNormal = computeMiteredNormal(
     postEndRTC,
     endRTC,
     startRTC,
     endEllipsoidNormal,
-    scratchEndFaceNormal
+    scratchEndFaceNormal,
   );
 
   const startEllipsoidNormals = this.startEllipsoidNormals;
   const endEllipsoidNormals = this.endEllipsoidNormals;
   const startPositionAndHeights = this.startPositionAndHeights;
-  const startFaceNormalAndVertexCornerIds = this
-    .startFaceNormalAndVertexCornerIds;
+  const startFaceNormalAndVertexCornerIds =
+    this.startFaceNormalAndVertexCornerIds;
   const endPositionAndHeights = this.endPositionAndHeights;
   const endFaceNormalAndHalfWidths = this.endFaceNormalAndHalfWidths;
   const vertexBatchIds = this.vertexBatchIds;
@@ -288,7 +288,7 @@ VertexAttributesAndIndices.prototype.addVolume = function (
     Cartesian3.pack(
       startFaceNormal,
       startFaceNormalAndVertexCornerIds,
-      vec4Offset
+      vec4Offset,
     );
     startFaceNormalAndVertexCornerIds[vec4Offset + 3] = i;
 
@@ -355,11 +355,11 @@ function createVectorTileClampedPolylines(parameters, transferableObjects) {
   const uBuffer = encodedPositions.subarray(0, positionsLength);
   const vBuffer = encodedPositions.subarray(
     positionsLength,
-    2 * positionsLength
+    2 * positionsLength,
   );
   const heightBuffer = encodedPositions.subarray(
     2 * positionsLength,
-    3 * positionsLength
+    3 * positionsLength,
   );
   AttributeCompression.zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer);
 
@@ -383,7 +383,7 @@ function createVectorTileClampedPolylines(parameters, transferableObjects) {
     minimumHeight,
     maximumHeight,
     ellipsoid,
-    center
+    center,
   );
 
   positionsLength = uBuffer.length;
@@ -405,12 +405,12 @@ function createVectorTileClampedPolylines(parameters, transferableObjects) {
       const volumeStart = Cartesian3.unpack(
         positionsRTC,
         currentPositionIndex,
-        scratchP0
+        scratchP0,
       );
       const volumeEnd = Cartesian3.unpack(
         positionsRTC,
         currentPositionIndex + 3,
-        scratchP1
+        scratchP1,
       );
 
       let startHeight = heightBuffer[currentHeightIndex];
@@ -418,12 +418,12 @@ function createVectorTileClampedPolylines(parameters, transferableObjects) {
       startHeight = CesiumMath.lerp(
         minimumHeight,
         maximumHeight,
-        startHeight / MAX_SHORT
+        startHeight / MAX_SHORT,
       );
       endHeight = CesiumMath.lerp(
         minimumHeight,
         maximumHeight,
-        endHeight / MAX_SHORT
+        endHeight / MAX_SHORT,
       );
 
       currentHeightIndex++;
@@ -437,7 +437,7 @@ function createVectorTileClampedPolylines(parameters, transferableObjects) {
         const finalPosition = Cartesian3.unpack(
           positionsRTC,
           finalPositionIndex,
-          scratchPrev
+          scratchPrev,
         );
         if (Cartesian3.equals(finalPosition, volumeStart)) {
           Cartesian3.unpack(positionsRTC, finalPositionIndex - 3, preStart);
@@ -445,7 +445,7 @@ function createVectorTileClampedPolylines(parameters, transferableObjects) {
           const offsetPastStart = Cartesian3.subtract(
             volumeStart,
             volumeEnd,
-            scratchPrev
+            scratchPrev,
           );
           preStart = Cartesian3.add(offsetPastStart, volumeStart, scratchPrev);
         }
@@ -458,19 +458,19 @@ function createVectorTileClampedPolylines(parameters, transferableObjects) {
         const firstPosition = Cartesian3.unpack(
           positionsRTC,
           volumeFirstPositionIndex,
-          scratchNext
+          scratchNext,
         );
         if (Cartesian3.equals(firstPosition, volumeEnd)) {
           Cartesian3.unpack(
             positionsRTC,
             volumeFirstPositionIndex + 3,
-            postEnd
+            postEnd,
           );
         } else {
           const offsetPastEnd = Cartesian3.subtract(
             volumeEnd,
             volumeStart,
-            scratchNext
+            scratchNext,
           );
           postEnd = Cartesian3.add(offsetPastEnd, volumeEnd, scratchNext);
         }
@@ -488,7 +488,7 @@ function createVectorTileClampedPolylines(parameters, transferableObjects) {
         halfWidth,
         batchId,
         center,
-        ellipsoid
+        ellipsoid,
       );
 
       currentPositionIndex += 3;
@@ -503,7 +503,7 @@ function createVectorTileClampedPolylines(parameters, transferableObjects) {
   transferableObjects.push(attribsAndIndices.endEllipsoidNormals.buffer);
   transferableObjects.push(attribsAndIndices.startPositionAndHeights.buffer);
   transferableObjects.push(
-    attribsAndIndices.startFaceNormalAndVertexCornerIds.buffer
+    attribsAndIndices.startFaceNormalAndVertexCornerIds.buffer,
   );
   transferableObjects.push(attribsAndIndices.endPositionAndHeights.buffer);
   transferableObjects.push(attribsAndIndices.endFaceNormalAndHalfWidths.buffer);

package/Source/Workers/createVectorTileGeometries.js

@@ -31,7 +31,7 @@ function boxModelMatrixAndBoundingVolume(boxes, index) {
   const boxModelMatrix = Matrix4.unpack(
     boxes,
     boxIndex,
-    scratchModelMatrixAndBV.modelMatrix
+    scratchModelMatrixAndBV.modelMatrix,
   );
   Matrix4.multiplyByScale(boxModelMatrix, dimensions, boxModelMatrix);
 
@@ -51,13 +51,13 @@ function cylinderModelMatrixAndBoundingVolume(cylinders, index) {
     cylinderRadius,
     cylinderRadius,
     length,
-    scratchCartesian
+    scratchCartesian,
   );
 
   const cylinderModelMatrix = Matrix4.unpack(
     cylinders,
     cylinderIndex,
-    scratchModelMatrixAndBV.modelMatrix
+    scratchModelMatrixAndBV.modelMatrix,
   );
   Matrix4.multiplyByScale(cylinderModelMatrix, scale, cylinderModelMatrix);
 
@@ -77,7 +77,7 @@ function ellipsoidModelMatrixAndBoundingVolume(ellipsoids, index) {
   const ellipsoidModelMatrix = Matrix4.unpack(
     ellipsoids,
     ellipsoidIndex,
-    scratchModelMatrixAndBV.modelMatrix
+    scratchModelMatrixAndBV.modelMatrix,
   );
   Matrix4.multiplyByScale(ellipsoidModelMatrix, radii, ellipsoidModelMatrix);
 
@@ -96,16 +96,16 @@ function sphereModelMatrixAndBoundingVolume(spheres, index) {
   const sphereTranslation = Cartesian3.unpack(
     spheres,
     sphereIndex,
-    scratchCartesian
+    scratchCartesian,
   );
   const sphereModelMatrix = Matrix4.fromTranslation(
     sphereTranslation,
-    scratchModelMatrixAndBV.modelMatrix
+    scratchModelMatrixAndBV.modelMatrix,
   );
   Matrix4.multiplyByUniformScale(
     sphereModelMatrix,
     sphereRadius,
-    sphereModelMatrix
+    sphereModelMatrix,
   );
 
   const boundingVolume = scratchModelMatrixAndBV.boundingVolume;
@@ -122,7 +122,7 @@ function createPrimitive(
   primitive,
   primitiveBatchIds,
   geometry,
-  getModelMatrixAndBoundingVolume
+  getModelMatrixAndBoundingVolume,
 ) {
   if (!defined(primitive)) {
     return;
@@ -154,7 +154,7 @@ function createPrimitive(
   for (let i = 0; i < numberOfPrimitives; ++i) {
     const primitiveModelMatrixAndBV = getModelMatrixAndBoundingVolume(
       primitive,
-      i
+      i,
     );
     const primitiveModelMatrix = primitiveModelMatrixAndBV.modelMatrix;
     Matrix4.multiply(modelMatrix, primitiveModelMatrix, primitiveModelMatrix);
@@ -188,7 +188,7 @@ function createPrimitive(
     indexCounts[offset] = indicesLength;
     boundingVolumes[offset] = BoundingSphere.transform(
       primitiveModelMatrixAndBV.boundingVolume,
-      primitiveModelMatrix
+      primitiveModelMatrix,
     );
 
     positionOffset += positionsLength / 3;
@@ -324,7 +324,7 @@ function createVectorTileGeometries(parameters, transferableObjects) {
   const vertexBatchIds = new Uint16Array(numberOfPositions / 3);
   const indices = IndexDatatype.createTypedArray(
     numberOfPositions / 3,
-    numberOfIndices
+    numberOfIndices,
   );
 
   const numberOfGeometries =
@@ -360,44 +360,44 @@ function createVectorTileGeometries(parameters, transferableObjects) {
     boxes,
     boxBatchIds,
     boxGeometry,
-    boxModelMatrixAndBoundingVolume
+    boxModelMatrixAndBoundingVolume,
   );
   createPrimitive(
     options,
     cylinders,
     cylinderBatchIds,
     cylinderGeometry,
-    cylinderModelMatrixAndBoundingVolume
+    cylinderModelMatrixAndBoundingVolume,
   );
   createPrimitive(
     options,
     ellipsoids,
     ellipsoidBatchIds,
     ellipsoidGeometry,
-    ellipsoidModelMatrixAndBoundingVolume
+    ellipsoidModelMatrixAndBoundingVolume,
   );
   createPrimitive(
     options,
     spheres,
     sphereBatchIds,
     ellipsoidGeometry,
-    sphereModelMatrixAndBoundingVolume
+    sphereModelMatrixAndBoundingVolume,
   );
 
   const packedBuffer = packBuffer(
     indices.BYTES_PER_ELEMENT,
     batchedIndices,
-    boundingVolumes
+    boundingVolumes,
   );
   transferableObjects.push(
     positions.buffer,
     vertexBatchIds.buffer,
-    indices.buffer
+    indices.buffer,
   );
   transferableObjects.push(
     batchIds.buffer,
     indexOffsets.buffer,
-    indexCounts.buffer
+    indexCounts.buffer,
   );
   transferableObjects.push(packedBuffer.buffer);
 

package/Source/Workers/createVectorTilePoints.js

@@ -45,7 +45,7 @@ function createVectorTilePoints(parameters, transferableObjects) {
   const vBuffer = positions.subarray(positionsLength, 2 * positionsLength);
   const heightBuffer = positions.subarray(
     2 * positionsLength,
-    3 * positionsLength
+    3 * positionsLength,
   );
   AttributeCompression.zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer);
 
@@ -63,11 +63,11 @@ function createVectorTilePoints(parameters, transferableObjects) {
       lon,
       lat,
       alt,
-      scratchBVCartographic
+      scratchBVCartographic,
     );
     const decodedPosition = ellipsoid.cartographicToCartesian(
       cartographic,
-      scratchEncodedPosition
+      scratchEncodedPosition,
     );
     Cartesian3.pack(decodedPosition, decoded, i * 3);
   }

package/Source/Workers/createVectorTilePolygons.js

@@ -152,7 +152,7 @@ function createVectorTilePolygons(parameters, transferableObjects) {
     const cart = Cartographic.fromRadians(x, y, 0.0, scratchBVCartographic);
     const decodedPosition = ellipsoid.cartographicToCartesian(
       cart,
-      scratchEncodedPosition
+      scratchEncodedPosition,
     );
     Cartesian3.pack(decodedPosition, decodedPositions, i * 3);
   }
@@ -257,13 +257,13 @@ function createVectorTilePolygons(parameters, transferableObjects) {
       const position = Cartesian3.unpack(
         decodedPositions,
         polygonOffset * 3 + j * 3,
-        scratchEncodedPosition
+        scratchEncodedPosition,
       );
       ellipsoid.scaleToGeodeticSurface(position, position);
 
       const carto = ellipsoid.cartesianToCartographic(
         position,
-        scratchBVCartographic
+        scratchBVCartographic,
       );
       const lat = carto.latitude;
       const lon = carto.longitude;
@@ -277,23 +277,23 @@ function createVectorTilePolygons(parameters, transferableObjects) {
       let scaledNormal = Cartesian3.multiplyByScalar(
         normal,
         polygonMinimumHeight,
-        scratchScaledNormal
+        scratchScaledNormal,
       );
       const minHeightPosition = Cartesian3.add(
         position,
         scaledNormal,
-        scratchMinHeightPosition
+        scratchMinHeightPosition,
       );
 
       scaledNormal = Cartesian3.multiplyByScalar(
         normal,
         polygonMaximumHeight,
-        scaledNormal
+        scaledNormal,
       );
       const maxHeightPosition = Cartesian3.add(
         position,
         scaledNormal,
-        scratchMaxHeightPosition
+        scratchMaxHeightPosition,
       );
 
       Cartesian3.subtract(maxHeightPosition, center, maxHeightPosition);
@@ -319,7 +319,7 @@ function createVectorTilePolygons(parameters, transferableObjects) {
       rectangle,
       minHeight,
       maxHeight,
-      ellipsoid
+      ellipsoid,
     );
 
     let indicesIndex = buffer.indexOffset;
@@ -367,7 +367,7 @@ function createVectorTilePolygons(parameters, transferableObjects) {
 
   batchedIndices = IndexDatatype.createTypedArray(
     batchedPositions.length / 3,
-    batchedIndices
+    batchedIndices,
   );
 
   const batchedIndicesLength = batchedDrawCalls.length;
@@ -388,7 +388,7 @@ function createVectorTilePolygons(parameters, transferableObjects) {
   const packedBuffer = packBuffer(
     indexDatatype,
     boundingVolumes,
-    batchedDrawCalls
+    batchedDrawCalls,
   );
 
   transferableObjects.push(
@@ -397,7 +397,7 @@ function createVectorTilePolygons(parameters, transferableObjects) {
     batchedIndexOffsets.buffer,
     batchedIndexCounts.buffer,
     batchedIds.buffer,
-    packedBuffer.buffer
+    packedBuffer.buffer,
   );
 
   return {