@cesium/engine 21.0.1 → 22.0.0

package/Build/Workers/{chunk-LPKJSIMD.js → chunk-2D3GLFZD.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.134.1
+ * Version 1.135.0
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,41 +25,41 @@
 
 import {
   EllipseGeometryLibrary_default
-} from "./chunk-VVALNLSH.js";
+} from "./chunk-BJSNGGBM.js";
 import {
   GeometryOffsetAttribute_default
-} from "./chunk-MQPDOWGH.js";
+} from "./chunk-JDJAPBZP.js";
 import {
   IndexDatatype_default
-} from "./chunk-KVB73ECP.js";
+} from "./chunk-H7B7FU2U.js";
 import {
   GeometryAttributes_default
-} from "./chunk-DTKSVIH5.js";
+} from "./chunk-YLILBDWK.js";
 import {
   GeometryAttribute_default,
   Geometry_default,
   PrimitiveType_default
-} from "./chunk-2QPH5QDK.js";
+} from "./chunk-XPVZWY4A.js";
 import {
   BoundingSphere_default
-} from "./chunk-ASVODZNK.js";
+} from "./chunk-MXHRZHDF.js";
 import {
   ComponentDatatype_default
-} from "./chunk-UFSYRVC5.js";
+} from "./chunk-EZ7NJXQN.js";
 import {
   Cartesian3_default,
   Ellipsoid_default,
   Frozen_default
-} from "./chunk-LV3G32QE.js";
+} from "./chunk-RQRODXVN.js";
 import {
   Math_default
-} from "./chunk-LU7DLY2L.js";
+} from "./chunk-OE22564R.js";
 import {
   DeveloperError_default
-} from "./chunk-DBHL2UVG.js";
+} from "./chunk-W4PIP5PG.js";
 import {
   defined_default
-} from "./chunk-3RKX3UFI.js";
+} from "./chunk-75HAJIDT.js";
 
 // packages/engine/Source/Core/EllipseOutlineGeometry.js
 var scratchCartesian1 = new Cartesian3_default();

package/Build/Workers/chunk-34YXP222.js

@@ -0,0 +1,352 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.135.0
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  IndexDatatype_default
+} from "./chunk-H7B7FU2U.js";
+import {
+  Math_default
+} from "./chunk-OE22564R.js";
+import {
+  DeveloperError_default
+} from "./chunk-W4PIP5PG.js";
+import {
+  defined_default
+} from "./chunk-75HAJIDT.js";
+
+// packages/engine/Source/Core/TerrainProvider.js
+function TerrainProvider() {
+  DeveloperError_default.throwInstantiationError();
+}
+Object.defineProperties(TerrainProvider.prototype, {
+  /**
+   * Gets an event that is raised when the terrain provider encounters an asynchronous error.  By subscribing
+   * to the event, you will be notified of the error and can potentially recover from it.  Event listeners
+   * are passed an instance of {@link TileProviderError}.
+   * @memberof TerrainProvider.prototype
+   * @type {Event<TerrainProvider.ErrorEvent>}
+   * @readonly
+   */
+  errorEvent: {
+    get: DeveloperError_default.throwInstantiationError
+  },
+  /**
+   * Gets the credit to display when this terrain provider is active.  Typically this is used to credit
+   * the source of the terrain.
+   * @memberof TerrainProvider.prototype
+   * @type {Credit}
+   * @readonly
+   */
+  credit: {
+    get: DeveloperError_default.throwInstantiationError
+  },
+  /**
+   * Gets the tiling scheme used by the provider.
+   * @memberof TerrainProvider.prototype
+   * @type {TilingScheme}
+   * @readonly
+   */
+  tilingScheme: {
+    get: DeveloperError_default.throwInstantiationError
+  },
+  /**
+   * Gets a value indicating whether or not the provider includes a water mask.  The water mask
+   * indicates which areas of the globe are water rather than land, so they can be rendered
+   * as a reflective surface with animated waves.
+   * @memberof TerrainProvider.prototype
+   * @type {boolean}
+   * @readonly
+   */
+  hasWaterMask: {
+    get: DeveloperError_default.throwInstantiationError
+  },
+  /**
+   * Gets a value indicating whether or not the requested tiles include vertex normals.
+   * @memberof TerrainProvider.prototype
+   * @type {boolean}
+   * @readonly
+   */
+  hasVertexNormals: {
+    get: DeveloperError_default.throwInstantiationError
+  },
+  /**
+   * Gets an object that can be used to determine availability of terrain from this provider, such as
+   * at points and in rectangles. This property may be undefined if availability
+   * information is not available.
+   * @memberof TerrainProvider.prototype
+   * @type {TileAvailability|undefined}
+   * @readonly
+   */
+  availability: {
+    get: DeveloperError_default.throwInstantiationError
+  }
+});
+var regularGridIndicesCache = [];
+TerrainProvider.getRegularGridIndices = function(width, height) {
+  if (width * height >= Math_default.FOUR_GIGABYTES) {
+    throw new DeveloperError_default(
+      "The total number of vertices (width * height) must be less than 4,294,967,296."
+    );
+  }
+  let byWidth = regularGridIndicesCache[width];
+  if (!defined_default(byWidth)) {
+    regularGridIndicesCache[width] = byWidth = [];
+  }
+  let indices = byWidth[height];
+  if (!defined_default(indices)) {
+    if (width * height < Math_default.SIXTY_FOUR_KILOBYTES) {
+      indices = byWidth[height] = new Uint16Array(
+        (width - 1) * (height - 1) * 6
+      );
+    } else {
+      indices = byWidth[height] = new Uint32Array(
+        (width - 1) * (height - 1) * 6
+      );
+    }
+    addRegularGridIndices(width, height, indices, 0);
+  }
+  return indices;
+};
+var regularGridAndEdgeIndicesCache = [];
+TerrainProvider.getRegularGridIndicesAndEdgeIndices = function(width, height) {
+  if (width * height >= Math_default.FOUR_GIGABYTES) {
+    throw new DeveloperError_default(
+      "The total number of vertices (width * height) must be less than 4,294,967,296."
+    );
+  }
+  let byWidth = regularGridAndEdgeIndicesCache[width];
+  if (!defined_default(byWidth)) {
+    regularGridAndEdgeIndicesCache[width] = byWidth = [];
+  }
+  let indicesAndEdges = byWidth[height];
+  if (!defined_default(indicesAndEdges)) {
+    const indices = TerrainProvider.getRegularGridIndices(width, height);
+    const edgeIndices = getEdgeIndices(width, height);
+    const westIndicesSouthToNorth = edgeIndices.westIndicesSouthToNorth;
+    const southIndicesEastToWest = edgeIndices.southIndicesEastToWest;
+    const eastIndicesNorthToSouth = edgeIndices.eastIndicesNorthToSouth;
+    const northIndicesWestToEast = edgeIndices.northIndicesWestToEast;
+    indicesAndEdges = byWidth[height] = {
+      indices,
+      westIndicesSouthToNorth,
+      southIndicesEastToWest,
+      eastIndicesNorthToSouth,
+      northIndicesWestToEast
+    };
+  }
+  return indicesAndEdges;
+};
+var regularGridAndSkirtAndEdgeIndicesCache = [];
+TerrainProvider.getRegularGridAndSkirtIndicesAndEdgeIndices = function(width, height) {
+  if (width * height >= Math_default.FOUR_GIGABYTES) {
+    throw new DeveloperError_default(
+      "The total number of vertices (width * height) must be less than 4,294,967,296."
+    );
+  }
+  let byWidth = regularGridAndSkirtAndEdgeIndicesCache[width];
+  if (!defined_default(byWidth)) {
+    regularGridAndSkirtAndEdgeIndicesCache[width] = byWidth = [];
+  }
+  let indicesAndEdges = byWidth[height];
+  if (!defined_default(indicesAndEdges)) {
+    const gridVertexCount = width * height;
+    const gridIndexCount = (width - 1) * (height - 1) * 6;
+    const edgeVertexCount = width * 2 + height * 2;
+    const edgeIndexCount = Math.max(0, edgeVertexCount - 4) * 6;
+    const vertexCount = gridVertexCount + edgeVertexCount;
+    const indexCount = gridIndexCount + edgeIndexCount;
+    const edgeIndices = getEdgeIndices(width, height);
+    const westIndicesSouthToNorth = edgeIndices.westIndicesSouthToNorth;
+    const southIndicesEastToWest = edgeIndices.southIndicesEastToWest;
+    const eastIndicesNorthToSouth = edgeIndices.eastIndicesNorthToSouth;
+    const northIndicesWestToEast = edgeIndices.northIndicesWestToEast;
+    const indices = IndexDatatype_default.createTypedArray(vertexCount, indexCount);
+    addRegularGridIndices(width, height, indices, 0);
+    TerrainProvider.addSkirtIndices(
+      westIndicesSouthToNorth,
+      southIndicesEastToWest,
+      eastIndicesNorthToSouth,
+      northIndicesWestToEast,
+      gridVertexCount,
+      indices,
+      gridIndexCount
+    );
+    indicesAndEdges = byWidth[height] = {
+      indices,
+      westIndicesSouthToNorth,
+      southIndicesEastToWest,
+      eastIndicesNorthToSouth,
+      northIndicesWestToEast,
+      indexCountWithoutSkirts: gridIndexCount
+    };
+  }
+  return indicesAndEdges;
+};
+TerrainProvider.getSkirtVertexCount = function(westIndicesSouthToNorth, southIndicesEastToWest, eastIndicesNorthToSouth, northIndicesWestToEast) {
+  return westIndicesSouthToNorth.length + southIndicesEastToWest.length + eastIndicesNorthToSouth.length + northIndicesWestToEast.length;
+};
+TerrainProvider.getSkirtIndexCount = function(skirtVertexCount) {
+  return (skirtVertexCount - 4) * 2 * 3;
+};
+TerrainProvider.getSkirtIndexCountWithFilledCorners = function(skirtVertexCount) {
+  return ((skirtVertexCount - 4) * 2 + 4) * 3;
+};
+TerrainProvider.addSkirtIndices = function(westIndicesSouthToNorth, southIndicesEastToWest, eastIndicesNorthToSouth, northIndicesWestToEast, vertexCount, indices, offset) {
+  let vertexIndex = vertexCount;
+  offset = addSkirtIndices(
+    westIndicesSouthToNorth,
+    vertexIndex,
+    indices,
+    offset
+  );
+  vertexIndex += westIndicesSouthToNorth.length;
+  offset = addSkirtIndices(
+    southIndicesEastToWest,
+    vertexIndex,
+    indices,
+    offset
+  );
+  vertexIndex += southIndicesEastToWest.length;
+  offset = addSkirtIndices(
+    eastIndicesNorthToSouth,
+    vertexIndex,
+    indices,
+    offset
+  );
+  vertexIndex += eastIndicesNorthToSouth.length;
+  addSkirtIndices(northIndicesWestToEast, vertexIndex, indices, offset);
+};
+TerrainProvider.addSkirtIndicesWithFilledCorners = function(westIndicesSouthToNorth, southIndicesEastToWest, eastIndicesNorthToSouth, northIndicesWestToEast, vertexCount, indices, offset) {
+  TerrainProvider.addSkirtIndices(
+    westIndicesSouthToNorth,
+    southIndicesEastToWest,
+    eastIndicesNorthToSouth,
+    northIndicesWestToEast,
+    vertexCount,
+    indices,
+    offset
+  );
+  const skirtVertexCount = TerrainProvider.getSkirtVertexCount(
+    westIndicesSouthToNorth,
+    southIndicesEastToWest,
+    eastIndicesNorthToSouth,
+    northIndicesWestToEast
+  );
+  const skirtIndexCountWithoutCaps = TerrainProvider.getSkirtIndexCount(skirtVertexCount);
+  const cornerStartIdx = offset + skirtIndexCountWithoutCaps;
+  const cornerSWIndex = westIndicesSouthToNorth[0];
+  const cornerNWIndex = northIndicesWestToEast[0];
+  const cornerNEIndex = eastIndicesNorthToSouth[0];
+  const cornerSEIndex = southIndicesEastToWest[0];
+  const westSouthIndex = vertexCount;
+  const westNorthIndex = westSouthIndex + westIndicesSouthToNorth.length - 1;
+  const southEastIndex = westNorthIndex + 1;
+  const southWestIndex = southEastIndex + southIndicesEastToWest.length - 1;
+  const eastNorthIndex = southWestIndex + 1;
+  const eastSouthIndex = eastNorthIndex + eastIndicesNorthToSouth.length - 1;
+  const northWestIndex = eastSouthIndex + 1;
+  const northEastIndex = northWestIndex + northIndicesWestToEast.length - 1;
+  indices[cornerStartIdx + 0] = cornerSWIndex;
+  indices[cornerStartIdx + 1] = westSouthIndex;
+  indices[cornerStartIdx + 2] = southWestIndex;
+  indices[cornerStartIdx + 3] = cornerSEIndex;
+  indices[cornerStartIdx + 4] = southEastIndex;
+  indices[cornerStartIdx + 5] = eastSouthIndex;
+  indices[cornerStartIdx + 6] = cornerNEIndex;
+  indices[cornerStartIdx + 7] = eastNorthIndex;
+  indices[cornerStartIdx + 8] = northEastIndex;
+  indices[cornerStartIdx + 9] = cornerNWIndex;
+  indices[cornerStartIdx + 10] = northWestIndex;
+  indices[cornerStartIdx + 11] = westNorthIndex;
+};
+function getEdgeIndices(width, height) {
+  const westIndicesSouthToNorth = new Array(height);
+  const southIndicesEastToWest = new Array(width);
+  const eastIndicesNorthToSouth = new Array(height);
+  const northIndicesWestToEast = new Array(width);
+  let i;
+  for (i = 0; i < width; ++i) {
+    northIndicesWestToEast[i] = i;
+    southIndicesEastToWest[i] = width * height - 1 - i;
+  }
+  for (i = 0; i < height; ++i) {
+    eastIndicesNorthToSouth[i] = (i + 1) * width - 1;
+    westIndicesSouthToNorth[i] = (height - i - 1) * width;
+  }
+  return {
+    westIndicesSouthToNorth,
+    southIndicesEastToWest,
+    eastIndicesNorthToSouth,
+    northIndicesWestToEast
+  };
+}
+function addRegularGridIndices(width, height, indices, offset) {
+  let index = 0;
+  for (let j = 0; j < height - 1; ++j) {
+    for (let i = 0; i < width - 1; ++i) {
+      const upperLeft = index;
+      const lowerLeft = upperLeft + width;
+      const lowerRight = lowerLeft + 1;
+      const upperRight = upperLeft + 1;
+      indices[offset++] = upperLeft;
+      indices[offset++] = lowerLeft;
+      indices[offset++] = upperRight;
+      indices[offset++] = upperRight;
+      indices[offset++] = lowerLeft;
+      indices[offset++] = lowerRight;
+      ++index;
+    }
+    ++index;
+  }
+}
+function addSkirtIndices(edgeIndices, vertexIndex, indices, offset) {
+  let previousIndex = edgeIndices[0];
+  const length = edgeIndices.length;
+  for (let i = 1; i < length; ++i) {
+    const index = edgeIndices[i];
+    indices[offset++] = previousIndex;
+    indices[offset++] = index;
+    indices[offset++] = vertexIndex;
+    indices[offset++] = vertexIndex;
+    indices[offset++] = index;
+    indices[offset++] = vertexIndex + 1;
+    previousIndex = index;
+    ++vertexIndex;
+  }
+  return offset;
+}
+TerrainProvider.heightmapTerrainQuality = 0.25;
+TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap = function(ellipsoid, tileImageWidth, numberOfTilesAtLevelZero) {
+  return ellipsoid.maximumRadius * 2 * Math.PI * TerrainProvider.heightmapTerrainQuality / (tileImageWidth * numberOfTilesAtLevelZero);
+};
+TerrainProvider.prototype.requestTileGeometry = DeveloperError_default.throwInstantiationError;
+TerrainProvider.prototype.getLevelMaximumGeometricError = DeveloperError_default.throwInstantiationError;
+TerrainProvider.prototype.getTileDataAvailable = DeveloperError_default.throwInstantiationError;
+TerrainProvider.prototype.loadTileDataAvailability = DeveloperError_default.throwInstantiationError;
+var TerrainProvider_default = TerrainProvider;
+
+export {
+  TerrainProvider_default
+};

package/Build/Workers/{chunk-UKA7OISV.js → chunk-3GL53OCU.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.134.1
+ * Version 1.135.0
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -23,6 +23,9 @@
  * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
  */
 
+import {
+  RuntimeError_default
+} from "./chunk-5T5SY63I.js";
 import {
   Cartesian2_default,
   Cartesian3_default,
@@ -31,23 +34,20 @@ import {
   FeatureDetection_default,
   Frozen_default,
   Matrix3_default
-} from "./chunk-LV3G32QE.js";
+} from "./chunk-RQRODXVN.js";
 import {
   Math_default
-} from "./chunk-LU7DLY2L.js";
-import {
-  RuntimeError_default
-} from "./chunk-FE565QHX.js";
+} from "./chunk-OE22564R.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-DBHL2UVG.js";
+} from "./chunk-W4PIP5PG.js";
 import {
   __commonJS,
   __require,
   __toESM,
   defined_default
-} from "./chunk-3RKX3UFI.js";
+} from "./chunk-75HAJIDT.js";
 
 // node_modules/urijs/src/punycode.js
 var require_punycode = __commonJS({
@@ -6951,7 +6951,7 @@ Resource.prototype.fetchImage = function(options) {
   const skipColorSpaceConversion = options.skipColorSpaceConversion ?? false;
   checkAndResetRequest(this.request);
   if (!xhrBlobSupported || this.isDataUri || this.isBlobUri || !this.hasHeaders && !preferBlob) {
-    return fetchImage({
+    return this._fetchImage({
       resource: this,
       flipY,
       skipColorSpaceConversion,
@@ -6986,8 +6986,7 @@ Resource.prototype.fetchImage = function(options) {
     generatedBlobResource = new Resource({
       url: blobUrl
     });
-    return fetchImage({
-      resource: generatedBlobResource,
+    return generatedBlobResource._fetchImage({
       flipY,
       skipColorSpaceConversion,
       preferImageBitmap: false
@@ -7010,8 +7009,8 @@ Resource.prototype.fetchImage = function(options) {
     return Promise.reject(error);
   });
 };
-function fetchImage(options) {
-  const resource = options.resource;
+Resource.prototype._fetchImage = function(options) {
+  const resource = this;
   const flipY = options.flipY;
   const skipColorSpaceConversion = options.skipColorSpaceConversion;
   const preferImageBitmap = options.preferImageBitmap;
@@ -7045,8 +7044,7 @@ function fetchImage(options) {
       if (retry) {
         request.state = RequestState_default.UNISSUED;
         request.deferred = void 0;
-        return fetchImage({
-          resource,
+        return resource._fetchImage({
           flipY,
           skipColorSpaceConversion,
           preferImageBitmap
@@ -7055,7 +7053,7 @@ function fetchImage(options) {
       return Promise.reject(e);
     });
   });
-}
+};
 Resource.fetchImage = function(options) {
   const resource = new Resource(options);
   return resource.fetchImage({
@@ -7381,7 +7379,7 @@ Resource._Implementations.loadImageElement = function(url, crossOrigin, deferred
   }
   image.src = url;
 };
-Resource._Implementations.createImage = function(request, crossOrigin, deferred, flipY, skipColorSpaceConversion, preferImageBitmap) {
+Resource._Implementations.createImage = function(request, crossOrigin, deferred, flipY, skipColorSpaceConversion, preferImageBitmap, headers) {
   const url = request.url;
   Resource.supportsImageBitmapOptions().then(function(supportsImageBitmap) {
     if (!(supportsImageBitmap && preferImageBitmap)) {
@@ -7396,7 +7394,7 @@ Resource._Implementations.createImage = function(request, crossOrigin, deferred,
       responseType,
       method,
       void 0,
-      void 0,
+      headers,
       xhrDeferred,
       void 0,
       void 0,
@@ -10358,6 +10356,7 @@ var Matrix2_default = Matrix2;
 export {
   Cartesian4_default,
   Matrix4_default,
+  binarySearch_default,
   combine_default,
   Resource_default,
   buildModuleUrl_default,

package/Build/Workers/{chunk-WQZL6CA2.js → chunk-5B7VZQZY.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.134.1
+ * Version 1.135.0
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,20 +25,20 @@
 
 import {
   PolylinePipeline_default
-} from "./chunk-CBPNIEGH.js";
+} from "./chunk-7KAXDKRU.js";
 import {
   arrayRemoveDuplicates_default
-} from "./chunk-QNOIRRJK.js";
+} from "./chunk-VCVA7BMD.js";
 import {
   Cartesian3_default,
   Cartographic_default
-} from "./chunk-LV3G32QE.js";
+} from "./chunk-RQRODXVN.js";
 import {
   Math_default
-} from "./chunk-LU7DLY2L.js";
+} from "./chunk-OE22564R.js";
 import {
   defined_default
-} from "./chunk-3RKX3UFI.js";
+} from "./chunk-75HAJIDT.js";
 
 // packages/engine/Source/Core/WallGeometryLibrary.js
 var WallGeometryLibrary = {};

package/Build/Workers/{chunk-FE565QHX.js → chunk-5T5SY63I.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.134.1
+ * Version 1.135.0
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,7 +25,7 @@
 
 import {
   defined_default
-} from "./chunk-3RKX3UFI.js";
+} from "./chunk-75HAJIDT.js";
 
 // packages/engine/Source/Core/RuntimeError.js
 function RuntimeError(message) {

package/Build/Workers/{chunk-RR3NCT4R.js → chunk-5ZF53EY6.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.134.1
+ * Version 1.135.0
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,13 +25,13 @@
 
 import {
   Cartesian3_default
-} from "./chunk-LV3G32QE.js";
+} from "./chunk-RQRODXVN.js";
 import {
   Check_default
-} from "./chunk-DBHL2UVG.js";
+} from "./chunk-W4PIP5PG.js";
 import {
   defined_default
-} from "./chunk-3RKX3UFI.js";
+} from "./chunk-75HAJIDT.js";
 
 // packages/engine/Source/Core/EncodedCartesian3.js
 function EncodedCartesian3() {

package/Build/Workers/{chunk-PZUZCAX3.js → chunk-6HBKE43B.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.134.1
+ * Version 1.135.0
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -27,25 +27,25 @@ import {
   Cartesian4_default,
   Matrix2_default,
   Matrix4_default
-} from "./chunk-UKA7OISV.js";
+} from "./chunk-3GL53OCU.js";
 import {
   ComponentDatatype_default
-} from "./chunk-UFSYRVC5.js";
+} from "./chunk-EZ7NJXQN.js";
 import {
   Cartesian2_default,
   Cartesian3_default,
   Matrix3_default
-} from "./chunk-LV3G32QE.js";
+} from "./chunk-RQRODXVN.js";
 import {
   Math_default
-} from "./chunk-LU7DLY2L.js";
+} from "./chunk-OE22564R.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-DBHL2UVG.js";
+} from "./chunk-W4PIP5PG.js";
 import {
   defined_default
-} from "./chunk-3RKX3UFI.js";
+} from "./chunk-75HAJIDT.js";
 
 // packages/engine/Source/Scene/AttributeType.js
 var AttributeType = {