@hztxi/cesium-engine 25.0.1 → 25.0.3

package/Build/Workers/chunk-ZXRWKKJP.js

@@ -0,0 +1,398 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.144.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 {
+  CylinderGeometryLibrary_default
+} from "./chunk-UIQUUY4A.js";
+import {
+  GeometryOffsetAttribute_default
+} from "./chunk-SXSP3JHS.js";
+import {
+  VertexFormat_default
+} from "./chunk-Y5E2LVSX.js";
+import {
+  IndexDatatype_default
+} from "./chunk-QJJ3GXSH.js";
+import {
+  GeometryAttributes_default
+} from "./chunk-2P5SGQUU.js";
+import {
+  BoundingSphere_default
+} from "./chunk-UCOZLNHF.js";
+import {
+  GeometryAttribute_default,
+  Geometry_default,
+  PrimitiveType_default
+} from "./chunk-DHCQSFRN.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-6KWWDFT4.js";
+import {
+  Cartesian2_default
+} from "./chunk-UT7YX565.js";
+import {
+  Cartesian3_default,
+  Frozen_default
+} from "./chunk-76HD3HYN.js";
+import {
+  Math_default
+} from "./chunk-TA3PH4Q7.js";
+import {
+  DeveloperError_default
+} from "./chunk-UDKEO3UF.js";
+import {
+  defined_default
+} from "./chunk-NYQSZLRF.js";
+
+// packages/engine/Source/Core/CylinderGeometry.js
+var radiusScratch = new Cartesian2_default();
+var normalScratch = new Cartesian3_default();
+var bitangentScratch = new Cartesian3_default();
+var tangentScratch = new Cartesian3_default();
+var positionScratch = new Cartesian3_default();
+function CylinderGeometry(options) {
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  const length = options.length;
+  const topRadius = options.topRadius;
+  const bottomRadius = options.bottomRadius;
+  const vertexFormat = options.vertexFormat ?? VertexFormat_default.DEFAULT;
+  const slices = options.slices ?? 128;
+  if (!defined_default(length)) {
+    throw new DeveloperError_default("options.length must be defined.");
+  }
+  if (!defined_default(topRadius)) {
+    throw new DeveloperError_default("options.topRadius must be defined.");
+  }
+  if (!defined_default(bottomRadius)) {
+    throw new DeveloperError_default("options.bottomRadius must be defined.");
+  }
+  if (slices < 3) {
+    throw new DeveloperError_default(
+      "options.slices must be greater than or equal to 3."
+    );
+  }
+  if (defined_default(options.offsetAttribute) && options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
+    throw new DeveloperError_default(
+      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry."
+    );
+  }
+  this._length = length;
+  this._topRadius = topRadius;
+  this._bottomRadius = bottomRadius;
+  this._vertexFormat = VertexFormat_default.clone(vertexFormat);
+  this._slices = slices;
+  this._offsetAttribute = options.offsetAttribute;
+  this._workerName = "createCylinderGeometry";
+}
+CylinderGeometry.packedLength = VertexFormat_default.packedLength + 5;
+CylinderGeometry.pack = function(value, array, startingIndex) {
+  if (!defined_default(value)) {
+    throw new DeveloperError_default("value is required");
+  }
+  if (!defined_default(array)) {
+    throw new DeveloperError_default("array is required");
+  }
+  startingIndex = startingIndex ?? 0;
+  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
+  startingIndex += VertexFormat_default.packedLength;
+  array[startingIndex++] = value._length;
+  array[startingIndex++] = value._topRadius;
+  array[startingIndex++] = value._bottomRadius;
+  array[startingIndex++] = value._slices;
+  array[startingIndex] = value._offsetAttribute ?? -1;
+  return array;
+};
+var scratchVertexFormat = new VertexFormat_default();
+var scratchOptions = {
+  vertexFormat: scratchVertexFormat,
+  length: void 0,
+  topRadius: void 0,
+  bottomRadius: void 0,
+  slices: void 0,
+  offsetAttribute: void 0
+};
+CylinderGeometry.unpack = function(array, startingIndex, result) {
+  if (!defined_default(array)) {
+    throw new DeveloperError_default("array is required");
+  }
+  startingIndex = startingIndex ?? 0;
+  const vertexFormat = VertexFormat_default.unpack(
+    array,
+    startingIndex,
+    scratchVertexFormat
+  );
+  startingIndex += VertexFormat_default.packedLength;
+  const length = array[startingIndex++];
+  const topRadius = array[startingIndex++];
+  const bottomRadius = array[startingIndex++];
+  const slices = array[startingIndex++];
+  const offsetAttribute = array[startingIndex];
+  if (!defined_default(result)) {
+    scratchOptions.length = length;
+    scratchOptions.topRadius = topRadius;
+    scratchOptions.bottomRadius = bottomRadius;
+    scratchOptions.slices = slices;
+    scratchOptions.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+    return new CylinderGeometry(scratchOptions);
+  }
+  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
+  result._length = length;
+  result._topRadius = topRadius;
+  result._bottomRadius = bottomRadius;
+  result._slices = slices;
+  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+  return result;
+};
+CylinderGeometry.createGeometry = function(cylinderGeometry) {
+  let length = cylinderGeometry._length;
+  const topRadius = cylinderGeometry._topRadius;
+  const bottomRadius = cylinderGeometry._bottomRadius;
+  const vertexFormat = cylinderGeometry._vertexFormat;
+  const slices = cylinderGeometry._slices;
+  if (length <= 0 || topRadius < 0 || bottomRadius < 0 || topRadius === 0 && bottomRadius === 0) {
+    return;
+  }
+  const twoSlices = slices + slices;
+  const threeSlices = slices + twoSlices;
+  const numVertices = twoSlices + twoSlices;
+  const positions = CylinderGeometryLibrary_default.computePositions(
+    length,
+    topRadius,
+    bottomRadius,
+    slices,
+    true
+  );
+  const st = vertexFormat.st ? new Float32Array(numVertices * 2) : void 0;
+  const normals = vertexFormat.normal ? new Float32Array(numVertices * 3) : void 0;
+  const tangents = vertexFormat.tangent ? new Float32Array(numVertices * 3) : void 0;
+  const bitangents = vertexFormat.bitangent ? new Float32Array(numVertices * 3) : void 0;
+  let i;
+  const computeNormal = vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent;
+  if (computeNormal) {
+    const computeTangent = vertexFormat.tangent || vertexFormat.bitangent;
+    let normalIndex = 0;
+    let tangentIndex = 0;
+    let bitangentIndex = 0;
+    const theta = Math.atan2(bottomRadius - topRadius, length);
+    const normal = normalScratch;
+    normal.z = Math.sin(theta);
+    const normalScale = Math.cos(theta);
+    let tangent = tangentScratch;
+    let bitangent = bitangentScratch;
+    for (i = 0; i < slices; i++) {
+      const angle = i / slices * Math_default.TWO_PI;
+      const x = normalScale * Math.cos(angle);
+      const y = normalScale * Math.sin(angle);
+      if (computeNormal) {
+        normal.x = x;
+        normal.y = y;
+        if (computeTangent) {
+          tangent = Cartesian3_default.normalize(
+            Cartesian3_default.cross(Cartesian3_default.UNIT_Z, normal, tangent),
+            tangent
+          );
+        }
+        if (vertexFormat.normal) {
+          normals[normalIndex++] = normal.x;
+          normals[normalIndex++] = normal.y;
+          normals[normalIndex++] = normal.z;
+          normals[normalIndex++] = normal.x;
+          normals[normalIndex++] = normal.y;
+          normals[normalIndex++] = normal.z;
+        }
+        if (vertexFormat.tangent) {
+          tangents[tangentIndex++] = tangent.x;
+          tangents[tangentIndex++] = tangent.y;
+          tangents[tangentIndex++] = tangent.z;
+          tangents[tangentIndex++] = tangent.x;
+          tangents[tangentIndex++] = tangent.y;
+          tangents[tangentIndex++] = tangent.z;
+        }
+        if (vertexFormat.bitangent) {
+          bitangent = Cartesian3_default.normalize(
+            Cartesian3_default.cross(normal, tangent, bitangent),
+            bitangent
+          );
+          bitangents[bitangentIndex++] = bitangent.x;
+          bitangents[bitangentIndex++] = bitangent.y;
+          bitangents[bitangentIndex++] = bitangent.z;
+          bitangents[bitangentIndex++] = bitangent.x;
+          bitangents[bitangentIndex++] = bitangent.y;
+          bitangents[bitangentIndex++] = bitangent.z;
+        }
+      }
+    }
+    for (i = 0; i < slices; i++) {
+      if (vertexFormat.normal) {
+        normals[normalIndex++] = 0;
+        normals[normalIndex++] = 0;
+        normals[normalIndex++] = -1;
+      }
+      if (vertexFormat.tangent) {
+        tangents[tangentIndex++] = 1;
+        tangents[tangentIndex++] = 0;
+        tangents[tangentIndex++] = 0;
+      }
+      if (vertexFormat.bitangent) {
+        bitangents[bitangentIndex++] = 0;
+        bitangents[bitangentIndex++] = -1;
+        bitangents[bitangentIndex++] = 0;
+      }
+    }
+    for (i = 0; i < slices; i++) {
+      if (vertexFormat.normal) {
+        normals[normalIndex++] = 0;
+        normals[normalIndex++] = 0;
+        normals[normalIndex++] = 1;
+      }
+      if (vertexFormat.tangent) {
+        tangents[tangentIndex++] = 1;
+        tangents[tangentIndex++] = 0;
+        tangents[tangentIndex++] = 0;
+      }
+      if (vertexFormat.bitangent) {
+        bitangents[bitangentIndex++] = 0;
+        bitangents[bitangentIndex++] = 1;
+        bitangents[bitangentIndex++] = 0;
+      }
+    }
+  }
+  const numIndices = 12 * slices - 12;
+  const indices = IndexDatatype_default.createTypedArray(numVertices, numIndices);
+  let index = 0;
+  let j = 0;
+  for (i = 0; i < slices - 1; i++) {
+    indices[index++] = j;
+    indices[index++] = j + 2;
+    indices[index++] = j + 3;
+    indices[index++] = j;
+    indices[index++] = j + 3;
+    indices[index++] = j + 1;
+    j += 2;
+  }
+  indices[index++] = twoSlices - 2;
+  indices[index++] = 0;
+  indices[index++] = 1;
+  indices[index++] = twoSlices - 2;
+  indices[index++] = 1;
+  indices[index++] = twoSlices - 1;
+  for (i = 1; i < slices - 1; i++) {
+    indices[index++] = twoSlices + i + 1;
+    indices[index++] = twoSlices + i;
+    indices[index++] = twoSlices;
+  }
+  for (i = 1; i < slices - 1; i++) {
+    indices[index++] = threeSlices;
+    indices[index++] = threeSlices + i;
+    indices[index++] = threeSlices + i + 1;
+  }
+  let textureCoordIndex = 0;
+  if (vertexFormat.st) {
+    const rad = Math.max(topRadius, bottomRadius);
+    for (i = 0; i < numVertices; i++) {
+      const position = Cartesian3_default.fromArray(positions, i * 3, positionScratch);
+      st[textureCoordIndex++] = (position.x + rad) / (2 * rad);
+      st[textureCoordIndex++] = (position.y + rad) / (2 * rad);
+    }
+  }
+  const attributes = new GeometryAttributes_default();
+  if (vertexFormat.position) {
+    attributes.position = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.DOUBLE,
+      componentsPerAttribute: 3,
+      values: positions
+    });
+  }
+  if (vertexFormat.normal) {
+    attributes.normal = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: normals
+    });
+  }
+  if (vertexFormat.tangent) {
+    attributes.tangent = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: tangents
+    });
+  }
+  if (vertexFormat.bitangent) {
+    attributes.bitangent = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: bitangents
+    });
+  }
+  if (vertexFormat.st) {
+    attributes.st = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 2,
+      values: st
+    });
+  }
+  radiusScratch.x = length * 0.5;
+  radiusScratch.y = Math.max(bottomRadius, topRadius);
+  const boundingSphere = new BoundingSphere_default(
+    Cartesian3_default.ZERO,
+    Cartesian2_default.magnitude(radiusScratch)
+  );
+  if (defined_default(cylinderGeometry._offsetAttribute)) {
+    length = positions.length;
+    const offsetValue = cylinderGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+    const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
+    attributes.applyOffset = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: applyOffset
+    });
+  }
+  return new Geometry_default({
+    attributes,
+    indices,
+    primitiveType: PrimitiveType_default.TRIANGLES,
+    boundingSphere,
+    offsetAttribute: cylinderGeometry._offsetAttribute
+  });
+};
+var unitCylinderGeometry;
+CylinderGeometry.getUnitCylinder = function() {
+  if (!defined_default(unitCylinderGeometry)) {
+    unitCylinderGeometry = CylinderGeometry.createGeometry(
+      new CylinderGeometry({
+        topRadius: 1,
+        bottomRadius: 1,
+        length: 1,
+        vertexFormat: VertexFormat_default.POSITION_ONLY
+      })
+    );
+  }
+  return unitCylinderGeometry;
+};
+var CylinderGeometry_default = CylinderGeometry;
+
+export {
+  CylinderGeometry_default
+};

package/Build/Workers/combineGeometry.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.141.1
+ * Version 1.141.3
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,31 +25,31 @@
 
 import {
   PrimitivePipeline_default
-} from "./chunk-WWOR75YX.js";
+} from "./chunk-752QDGCS.js";
 import {
   createTaskProcessorWorker_default
-} from "./chunk-S2SZ2HYA.js";
-import "./chunk-DWNGALVJ.js";
-import "./chunk-NW27SGND.js";
-import "./chunk-4B3I4BQ3.js";
-import "./chunk-24H74D3Q.js";
-import "./chunk-Q2MV7V3J.js";
-import "./chunk-KFRGYJLT.js";
-import "./chunk-VG4FKBIJ.js";
-import "./chunk-5EN3SEJC.js";
-import "./chunk-P2DEQUE6.js";
-import "./chunk-MG54QB2S.js";
-import "./chunk-ZZIFOLD3.js";
-import "./chunk-3TK6563P.js";
-import "./chunk-SSNBEN3T.js";
-import "./chunk-I6PQQIM5.js";
-import "./chunk-APAN2W5B.js";
-import "./chunk-ZY636MPN.js";
-import "./chunk-7BWPTYVV.js";
-import "./chunk-LPWXXHTU.js";
-import "./chunk-PAO4TRRA.js";
-import "./chunk-6JM3OV5P.js";
-import "./chunk-AMW7Q4HY.js";
+} from "./chunk-BVAMP4M3.js";
+import "./chunk-YNWTO2WN.js";
+import "./chunk-TYW2D7VU.js";
+import "./chunk-73T2E2OA.js";
+import "./chunk-HQ2PXPP7.js";
+import "./chunk-SMZXVFCA.js";
+import "./chunk-OJK33YVT.js";
+import "./chunk-XQVSSVT2.js";
+import "./chunk-MUPWJMPP.js";
+import "./chunk-IC3HVJBG.js";
+import "./chunk-3GDVUAIX.js";
+import "./chunk-KJOVSN7J.js";
+import "./chunk-H52M4HMP.js";
+import "./chunk-37IVAHRF.js";
+import "./chunk-ANGZAKVP.js";
+import "./chunk-IRSD4EJW.js";
+import "./chunk-7I4AKIEV.js";
+import "./chunk-ILUFUAF3.js";
+import "./chunk-ILX5N5QR.js";
+import "./chunk-KYXZ3XTC.js";
+import "./chunk-MVBEMXN4.js";
+import "./chunk-2RC5GQMH.js";
 
 // packages/engine/Source/Workers/combineGeometry.js
 function combineGeometry(packedParameters, transferableObjects) {

package/Build/Workers/createBoxGeometry.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.141.1
+ * Version 1.141.3
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,25 +25,25 @@
 
 import {
   BoxGeometry_default
-} from "./chunk-HM6KRMLB.js";
-import "./chunk-KIRR4SHO.js";
-import "./chunk-XNSQLK46.js";
-import "./chunk-5EN3SEJC.js";
-import "./chunk-P2DEQUE6.js";
-import "./chunk-MG54QB2S.js";
-import "./chunk-ZZIFOLD3.js";
-import "./chunk-3TK6563P.js";
-import "./chunk-SSNBEN3T.js";
-import "./chunk-I6PQQIM5.js";
-import "./chunk-APAN2W5B.js";
-import "./chunk-ZY636MPN.js";
-import "./chunk-7BWPTYVV.js";
-import "./chunk-LPWXXHTU.js";
-import "./chunk-PAO4TRRA.js";
-import "./chunk-6JM3OV5P.js";
+} from "./chunk-KXNXQXP5.js";
+import "./chunk-AZGPL6BR.js";
+import "./chunk-CKWUU4JK.js";
+import "./chunk-MUPWJMPP.js";
+import "./chunk-IC3HVJBG.js";
+import "./chunk-3GDVUAIX.js";
+import "./chunk-KJOVSN7J.js";
+import "./chunk-H52M4HMP.js";
+import "./chunk-37IVAHRF.js";
+import "./chunk-ANGZAKVP.js";
+import "./chunk-IRSD4EJW.js";
+import "./chunk-7I4AKIEV.js";
+import "./chunk-ILUFUAF3.js";
+import "./chunk-ILX5N5QR.js";
+import "./chunk-KYXZ3XTC.js";
+import "./chunk-MVBEMXN4.js";
 import {
   defined_default
-} from "./chunk-AMW7Q4HY.js";
+} from "./chunk-2RC5GQMH.js";
 
 // packages/engine/Source/Workers/createBoxGeometry.js
 function createBoxGeometry(boxGeometry, offset) {

package/Build/Workers/createBoxOutlineGeometry.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.141.1
+ * Version 1.141.3
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,39 +25,39 @@
 
 import {
   GeometryOffsetAttribute_default
-} from "./chunk-KIRR4SHO.js";
+} from "./chunk-AZGPL6BR.js";
 import {
   GeometryAttributes_default
-} from "./chunk-5EN3SEJC.js";
+} from "./chunk-MUPWJMPP.js";
 import {
   GeometryAttribute_default,
   Geometry_default,
   PrimitiveType_default
-} from "./chunk-P2DEQUE6.js";
+} from "./chunk-IC3HVJBG.js";
 import {
   BoundingSphere_default
-} from "./chunk-MG54QB2S.js";
-import "./chunk-ZZIFOLD3.js";
-import "./chunk-3TK6563P.js";
-import "./chunk-SSNBEN3T.js";
+} from "./chunk-3GDVUAIX.js";
+import "./chunk-KJOVSN7J.js";
+import "./chunk-H52M4HMP.js";
+import "./chunk-37IVAHRF.js";
 import {
   ComponentDatatype_default
-} from "./chunk-I6PQQIM5.js";
-import "./chunk-APAN2W5B.js";
-import "./chunk-ZY636MPN.js";
-import "./chunk-7BWPTYVV.js";
+} from "./chunk-ANGZAKVP.js";
+import "./chunk-IRSD4EJW.js";
+import "./chunk-7I4AKIEV.js";
+import "./chunk-ILUFUAF3.js";
 import {
   Cartesian3_default,
   Frozen_default
-} from "./chunk-LPWXXHTU.js";
-import "./chunk-PAO4TRRA.js";
+} from "./chunk-ILX5N5QR.js";
+import "./chunk-KYXZ3XTC.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-6JM3OV5P.js";
+} from "./chunk-MVBEMXN4.js";
 import {
   defined_default
-} from "./chunk-AMW7Q4HY.js";
+} from "./chunk-2RC5GQMH.js";
 
 // packages/engine/Source/Core/BoxOutlineGeometry.js
 var diffScratch = new Cartesian3_default();

package/Build/Workers/createCircleGeometry.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.141.1
+ * Version 1.141.3
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,42 +25,42 @@
 
 import {
   EllipseGeometry_default
-} from "./chunk-BUS2WCDM.js";
-import "./chunk-Q3JUKGCA.js";
-import "./chunk-D6XIXIZN.js";
-import "./chunk-NW27SGND.js";
-import "./chunk-4B3I4BQ3.js";
-import "./chunk-24H74D3Q.js";
-import "./chunk-KIRR4SHO.js";
+} from "./chunk-BVFS5LSK.js";
+import "./chunk-WNAG4FHY.js";
+import "./chunk-LY5KUQ2L.js";
+import "./chunk-TYW2D7VU.js";
+import "./chunk-73T2E2OA.js";
+import "./chunk-HQ2PXPP7.js";
+import "./chunk-AZGPL6BR.js";
 import {
   VertexFormat_default
-} from "./chunk-XNSQLK46.js";
-import "./chunk-Q2MV7V3J.js";
-import "./chunk-KFRGYJLT.js";
-import "./chunk-VG4FKBIJ.js";
-import "./chunk-5EN3SEJC.js";
-import "./chunk-P2DEQUE6.js";
-import "./chunk-MG54QB2S.js";
-import "./chunk-ZZIFOLD3.js";
-import "./chunk-3TK6563P.js";
-import "./chunk-SSNBEN3T.js";
-import "./chunk-I6PQQIM5.js";
-import "./chunk-APAN2W5B.js";
-import "./chunk-ZY636MPN.js";
+} from "./chunk-CKWUU4JK.js";
+import "./chunk-SMZXVFCA.js";
+import "./chunk-OJK33YVT.js";
+import "./chunk-XQVSSVT2.js";
+import "./chunk-MUPWJMPP.js";
+import "./chunk-IC3HVJBG.js";
+import "./chunk-3GDVUAIX.js";
+import "./chunk-KJOVSN7J.js";
+import "./chunk-H52M4HMP.js";
+import "./chunk-37IVAHRF.js";
+import "./chunk-ANGZAKVP.js";
+import "./chunk-IRSD4EJW.js";
+import "./chunk-7I4AKIEV.js";
 import {
   Ellipsoid_default
-} from "./chunk-7BWPTYVV.js";
+} from "./chunk-ILUFUAF3.js";
 import {
   Cartesian3_default,
   Frozen_default
-} from "./chunk-LPWXXHTU.js";
-import "./chunk-PAO4TRRA.js";
+} from "./chunk-ILX5N5QR.js";
+import "./chunk-KYXZ3XTC.js";
 import {
   Check_default
-} from "./chunk-6JM3OV5P.js";
+} from "./chunk-MVBEMXN4.js";
 import {
   defined_default
-} from "./chunk-AMW7Q4HY.js";
+} from "./chunk-2RC5GQMH.js";
 
 // packages/engine/Source/Core/CircleGeometry.js
 function CircleGeometry(options) {