@cesium/engine 6.1.1 → 6.2.0

package/Build/Workers/{chunk-S7IBK36I.js → chunk-HFKSAB5K.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.113
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,46 +25,44 @@
 
 import {
   GeometryOffsetAttribute_default
-} from "./chunk-W7F5VTH6.js";
+} from "./chunk-MN34FIF5.js";
 import {
   VertexFormat_default
-} from "./chunk-ZTYE74E2.js";
+} from "./chunk-ZQRZBHYI.js";
 import {
   IndexDatatype_default
-} from "./chunk-J3U6Z5YQ.js";
+} from "./chunk-LX6XV4DK.js";
 import {
   GeometryAttributes_default
-} from "./chunk-SJDXMQSP.js";
+} from "./chunk-PIXK6KHB.js";
 import {
   GeometryAttribute_default,
   Geometry_default,
   PrimitiveType_default
-} from "./chunk-OTBRPBCC.js";
+} from "./chunk-R3HUGXBH.js";
 import {
   BoundingSphere_default
-} from "./chunk-D4YHO4NZ.js";
-import {
-  Cartesian2_default
-} from "./chunk-RSWBNJPT.js";
+} from "./chunk-HOT2SNXP.js";
 import {
   ComponentDatatype_default
-} from "./chunk-Z6LPXA7S.js";
+} from "./chunk-ARPTYYKS.js";
 import {
+  Cartesian2_default,
   Cartesian3_default,
   Ellipsoid_default
-} from "./chunk-PHQVHDVI.js";
+} from "./chunk-LGJUI2CE.js";
 import {
   Math_default
-} from "./chunk-IZED7ODV.js";
+} from "./chunk-BP467WX3.js";
 import {
   defaultValue_default
-} from "./chunk-C53JYYKX.js";
+} from "./chunk-CWJQGBWT.js";
 import {
   DeveloperError_default
-} from "./chunk-7FEGZO3D.js";
+} from "./chunk-5HLGKKG3.js";
 import {
   defined_default
-} from "./chunk-YS4KPNLC.js";
+} from "./chunk-YBKFS53K.js";
 
 // packages/engine/Source/Core/EllipsoidGeometry.js
 var scratchPosition = new Cartesian3_default();

package/Build/Workers/{chunk-D4YHO4NZ.js → chunk-HOT2SNXP.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.113
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,38 +25,38 @@
 
 import {
   combine_default
-} from "./chunk-HSW63JN4.js";
+} from "./chunk-4KP73B43.js";
 import {
-  Cartesian2_default,
   Cartesian4_default,
   Matrix4_default,
   Rectangle_default
-} from "./chunk-RSWBNJPT.js";
+} from "./chunk-3PW6ZBN4.js";
 import {
+  Cartesian2_default,
   Cartesian3_default,
   Cartographic_default,
   Ellipsoid_default,
   Matrix3_default
-} from "./chunk-PHQVHDVI.js";
+} from "./chunk-LGJUI2CE.js";
 import {
   Math_default
-} from "./chunk-IZED7ODV.js";
+} from "./chunk-BP467WX3.js";
 import {
   RuntimeError_default
-} from "./chunk-66CXKODF.js";
+} from "./chunk-RIDPF7PO.js";
 import {
   defaultValue_default
-} from "./chunk-C53JYYKX.js";
+} from "./chunk-CWJQGBWT.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-7FEGZO3D.js";
+} from "./chunk-5HLGKKG3.js";
 import {
   __commonJS,
   __require,
   __toESM,
   defined_default
-} from "./chunk-YS4KPNLC.js";
+} from "./chunk-YBKFS53K.js";
 
 // node_modules/urijs/src/punycode.js
 var require_punycode = __commonJS({
@@ -4962,14 +4962,8 @@ var requestCompletedEvent = new Event_default();
 function RequestScheduler() {
 }
 RequestScheduler.maximumRequests = 50;
-RequestScheduler.maximumRequestsPerServer = 6;
-RequestScheduler.requestsByServer = {
-  "api.cesium.com:443": 18,
-  "assets.ion.cesium.com:443": 18,
-  "ibasemaps-api.arcgis.com:443": 18,
-  "tile.googleapis.com:443": 18,
-  "tile.openstreetmap.org:443": 18
-};
+RequestScheduler.maximumRequestsPerServer = 18;
+RequestScheduler.requestsByServer = {};
 RequestScheduler.throttleRequests = true;
 RequestScheduler.debugShowStatistics = false;
 RequestScheduler.requestCompletedEvent = requestCompletedEvent;
@@ -7823,8 +7817,9 @@ Quaternion.computeAxis = function(quaternion, result) {
   Check_default.typeOf.object("quaternion", quaternion);
   Check_default.typeOf.object("result", result);
   const w = quaternion.w;
-  if (Math.abs(w - 1) < Math_default.EPSILON6) {
-    result.x = result.y = result.z = 0;
+  if (Math.abs(w - 1) < Math_default.EPSILON6 || Math.abs(w + 1) < Math_default.EPSILON6) {
+    result.x = 1;
+    result.y = result.z = 0;
     return result;
   }
   const scalar = 1 / Math.sqrt(1 - w * w);

package/Build/Workers/{chunk-5NZTU5YL.js → chunk-HPH5HSFE.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.113
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -26,7 +26,7 @@
 import {
   __commonJS,
   __require
-} from "./chunk-YS4KPNLC.js";
+} from "./chunk-YBKFS53K.js";
 
 // node_modules/draco3d/draco_decoder_nodejs.js
 var require_draco_decoder_nodejs = __commonJS({

package/Build/Workers/{chunk-KUB2HQXR.js → chunk-HPP4JLNH.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.113
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -26,23 +26,23 @@
 import {
   GeographicProjection_default,
   Intersect_default
-} from "./chunk-D4YHO4NZ.js";
+} from "./chunk-HOT2SNXP.js";
 import {
-  Cartesian2_default,
   Rectangle_default
-} from "./chunk-RSWBNJPT.js";
+} from "./chunk-3PW6ZBN4.js";
 import {
+  Cartesian2_default,
   Cartographic_default
-} from "./chunk-PHQVHDVI.js";
+} from "./chunk-LGJUI2CE.js";
 import {
   defaultValue_default
-} from "./chunk-C53JYYKX.js";
+} from "./chunk-CWJQGBWT.js";
 import {
   Check_default
-} from "./chunk-7FEGZO3D.js";
+} from "./chunk-5HLGKKG3.js";
 import {
   defined_default
-} from "./chunk-YS4KPNLC.js";
+} from "./chunk-YBKFS53K.js";
 
 // packages/engine/Source/Core/BoundingRectangle.js
 function BoundingRectangle(x, y, width, height) {

package/Build/Workers/{chunk-CHDJ66UM.js → chunk-HUPNRBWW.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.113
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,20 +25,20 @@
 
 import {
   PolylinePipeline_default
-} from "./chunk-3FCUUN6M.js";
+} from "./chunk-H5DUXHCV.js";
 import {
   arrayRemoveDuplicates_default
-} from "./chunk-DTNN3ODA.js";
+} from "./chunk-DMCSY5BU.js";
 import {
   Cartesian3_default,
   Cartographic_default
-} from "./chunk-PHQVHDVI.js";
+} from "./chunk-LGJUI2CE.js";
 import {
   Math_default
-} from "./chunk-IZED7ODV.js";
+} from "./chunk-BP467WX3.js";
 import {
   defined_default
-} from "./chunk-YS4KPNLC.js";
+} from "./chunk-YBKFS53K.js";
 
 // packages/engine/Source/Core/WallGeometryLibrary.js
 var WallGeometryLibrary = {};

package/Build/Workers/{chunk-VOAZN4IP.js → chunk-JGG36SQV.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.113
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,13 +25,13 @@
 
 import {
   Cartesian3_default
-} from "./chunk-PHQVHDVI.js";
+} from "./chunk-LGJUI2CE.js";
 import {
   Check_default
-} from "./chunk-7FEGZO3D.js";
+} from "./chunk-5HLGKKG3.js";
 import {
   defined_default
-} from "./chunk-YS4KPNLC.js";
+} from "./chunk-YBKFS53K.js";
 
 // packages/engine/Source/Core/EncodedCartesian3.js
 function EncodedCartesian3() {

package/Build/Workers/{chunk-PHQVHDVI.js → chunk-LGJUI2CE.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.113
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,17 +25,17 @@
 
 import {
   Math_default
-} from "./chunk-IZED7ODV.js";
+} from "./chunk-BP467WX3.js";
 import {
   defaultValue_default
-} from "./chunk-C53JYYKX.js";
+} from "./chunk-CWJQGBWT.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-7FEGZO3D.js";
+} from "./chunk-5HLGKKG3.js";
 import {
   defined_default
-} from "./chunk-YS4KPNLC.js";
+} from "./chunk-YBKFS53K.js";
 
 // packages/engine/Source/Core/Cartesian3.js
 function Cartesian3(x, y, z) {
@@ -758,6 +758,302 @@ Cartographic.prototype.toString = function() {
 };
 var Cartographic_default = Cartographic;
 
+// packages/engine/Source/Core/Cartesian2.js
+function Cartesian2(x, y) {
+  this.x = defaultValue_default(x, 0);
+  this.y = defaultValue_default(y, 0);
+}
+Cartesian2.fromElements = function(x, y, result) {
+  if (!defined_default(result)) {
+    return new Cartesian2(x, y);
+  }
+  result.x = x;
+  result.y = y;
+  return result;
+};
+Cartesian2.clone = function(cartesian, result) {
+  if (!defined_default(cartesian)) {
+    return void 0;
+  }
+  if (!defined_default(result)) {
+    return new Cartesian2(cartesian.x, cartesian.y);
+  }
+  result.x = cartesian.x;
+  result.y = cartesian.y;
+  return result;
+};
+Cartesian2.fromCartesian3 = Cartesian2.clone;
+Cartesian2.fromCartesian4 = Cartesian2.clone;
+Cartesian2.packedLength = 2;
+Cartesian2.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  array[startingIndex++] = value.x;
+  array[startingIndex] = value.y;
+  return array;
+};
+Cartesian2.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  if (!defined_default(result)) {
+    result = new Cartesian2();
+  }
+  result.x = array[startingIndex++];
+  result.y = array[startingIndex];
+  return result;
+};
+Cartesian2.packArray = function(array, result) {
+  Check_default.defined("array", array);
+  const length = array.length;
+  const resultLength = length * 2;
+  if (!defined_default(result)) {
+    result = new Array(resultLength);
+  } else if (!Array.isArray(result) && result.length !== resultLength) {
+    throw new DeveloperError_default(
+      "If result is a typed array, it must have exactly array.length * 2 elements"
+    );
+  } else if (result.length !== resultLength) {
+    result.length = resultLength;
+  }
+  for (let i = 0; i < length; ++i) {
+    Cartesian2.pack(array[i], result, i * 2);
+  }
+  return result;
+};
+Cartesian2.unpackArray = function(array, result) {
+  Check_default.defined("array", array);
+  Check_default.typeOf.number.greaterThanOrEquals("array.length", array.length, 2);
+  if (array.length % 2 !== 0) {
+    throw new DeveloperError_default("array length must be a multiple of 2.");
+  }
+  const length = array.length;
+  if (!defined_default(result)) {
+    result = new Array(length / 2);
+  } else {
+    result.length = length / 2;
+  }
+  for (let i = 0; i < length; i += 2) {
+    const index = i / 2;
+    result[index] = Cartesian2.unpack(array, i, result[index]);
+  }
+  return result;
+};
+Cartesian2.fromArray = Cartesian2.unpack;
+Cartesian2.maximumComponent = function(cartesian) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  return Math.max(cartesian.x, cartesian.y);
+};
+Cartesian2.minimumComponent = function(cartesian) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  return Math.min(cartesian.x, cartesian.y);
+};
+Cartesian2.minimumByComponent = function(first, second, result) {
+  Check_default.typeOf.object("first", first);
+  Check_default.typeOf.object("second", second);
+  Check_default.typeOf.object("result", result);
+  result.x = Math.min(first.x, second.x);
+  result.y = Math.min(first.y, second.y);
+  return result;
+};
+Cartesian2.maximumByComponent = function(first, second, result) {
+  Check_default.typeOf.object("first", first);
+  Check_default.typeOf.object("second", second);
+  Check_default.typeOf.object("result", result);
+  result.x = Math.max(first.x, second.x);
+  result.y = Math.max(first.y, second.y);
+  return result;
+};
+Cartesian2.clamp = function(value, min, max, result) {
+  Check_default.typeOf.object("value", value);
+  Check_default.typeOf.object("min", min);
+  Check_default.typeOf.object("max", max);
+  Check_default.typeOf.object("result", result);
+  const x = Math_default.clamp(value.x, min.x, max.x);
+  const y = Math_default.clamp(value.y, min.y, max.y);
+  result.x = x;
+  result.y = y;
+  return result;
+};
+Cartesian2.magnitudeSquared = function(cartesian) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  return cartesian.x * cartesian.x + cartesian.y * cartesian.y;
+};
+Cartesian2.magnitude = function(cartesian) {
+  return Math.sqrt(Cartesian2.magnitudeSquared(cartesian));
+};
+var distanceScratch2 = new Cartesian2();
+Cartesian2.distance = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Cartesian2.subtract(left, right, distanceScratch2);
+  return Cartesian2.magnitude(distanceScratch2);
+};
+Cartesian2.distanceSquared = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Cartesian2.subtract(left, right, distanceScratch2);
+  return Cartesian2.magnitudeSquared(distanceScratch2);
+};
+Cartesian2.normalize = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  const magnitude = Cartesian2.magnitude(cartesian);
+  result.x = cartesian.x / magnitude;
+  result.y = cartesian.y / magnitude;
+  if (isNaN(result.x) || isNaN(result.y)) {
+    throw new DeveloperError_default("normalized result is not a number");
+  }
+  return result;
+};
+Cartesian2.dot = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  return left.x * right.x + left.y * right.y;
+};
+Cartesian2.cross = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  return left.x * right.y - left.y * right.x;
+};
+Cartesian2.multiplyComponents = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Check_default.typeOf.object("result", result);
+  result.x = left.x * right.x;
+  result.y = left.y * right.y;
+  return result;
+};
+Cartesian2.divideComponents = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Check_default.typeOf.object("result", result);
+  result.x = left.x / right.x;
+  result.y = left.y / right.y;
+  return result;
+};
+Cartesian2.add = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Check_default.typeOf.object("result", result);
+  result.x = left.x + right.x;
+  result.y = left.y + right.y;
+  return result;
+};
+Cartesian2.subtract = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Check_default.typeOf.object("result", result);
+  result.x = left.x - right.x;
+  result.y = left.y - right.y;
+  return result;
+};
+Cartesian2.multiplyByScalar = function(cartesian, scalar, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.number("scalar", scalar);
+  Check_default.typeOf.object("result", result);
+  result.x = cartesian.x * scalar;
+  result.y = cartesian.y * scalar;
+  return result;
+};
+Cartesian2.divideByScalar = function(cartesian, scalar, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.number("scalar", scalar);
+  Check_default.typeOf.object("result", result);
+  result.x = cartesian.x / scalar;
+  result.y = cartesian.y / scalar;
+  return result;
+};
+Cartesian2.negate = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  result.x = -cartesian.x;
+  result.y = -cartesian.y;
+  return result;
+};
+Cartesian2.abs = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  result.x = Math.abs(cartesian.x);
+  result.y = Math.abs(cartesian.y);
+  return result;
+};
+var lerpScratch2 = new Cartesian2();
+Cartesian2.lerp = function(start, end, t, result) {
+  Check_default.typeOf.object("start", start);
+  Check_default.typeOf.object("end", end);
+  Check_default.typeOf.number("t", t);
+  Check_default.typeOf.object("result", result);
+  Cartesian2.multiplyByScalar(end, t, lerpScratch2);
+  result = Cartesian2.multiplyByScalar(start, 1 - t, result);
+  return Cartesian2.add(lerpScratch2, result, result);
+};
+var angleBetweenScratch3 = new Cartesian2();
+var angleBetweenScratch22 = new Cartesian2();
+Cartesian2.angleBetween = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Cartesian2.normalize(left, angleBetweenScratch3);
+  Cartesian2.normalize(right, angleBetweenScratch22);
+  return Math_default.acosClamped(
+    Cartesian2.dot(angleBetweenScratch3, angleBetweenScratch22)
+  );
+};
+var mostOrthogonalAxisScratch2 = new Cartesian2();
+Cartesian2.mostOrthogonalAxis = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  const f = Cartesian2.normalize(cartesian, mostOrthogonalAxisScratch2);
+  Cartesian2.abs(f, f);
+  if (f.x <= f.y) {
+    result = Cartesian2.clone(Cartesian2.UNIT_X, result);
+  } else {
+    result = Cartesian2.clone(Cartesian2.UNIT_Y, result);
+  }
+  return result;
+};
+Cartesian2.equals = function(left, right) {
+  return left === right || defined_default(left) && defined_default(right) && left.x === right.x && left.y === right.y;
+};
+Cartesian2.equalsArray = function(cartesian, array, offset) {
+  return cartesian.x === array[offset] && cartesian.y === array[offset + 1];
+};
+Cartesian2.equalsEpsilon = function(left, right, relativeEpsilon, absoluteEpsilon) {
+  return left === right || defined_default(left) && defined_default(right) && Math_default.equalsEpsilon(
+    left.x,
+    right.x,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    left.y,
+    right.y,
+    relativeEpsilon,
+    absoluteEpsilon
+  );
+};
+Cartesian2.ZERO = Object.freeze(new Cartesian2(0, 0));
+Cartesian2.ONE = Object.freeze(new Cartesian2(1, 1));
+Cartesian2.UNIT_X = Object.freeze(new Cartesian2(1, 0));
+Cartesian2.UNIT_Y = Object.freeze(new Cartesian2(0, 1));
+Cartesian2.prototype.clone = function(result) {
+  return Cartesian2.clone(this, result);
+};
+Cartesian2.prototype.equals = function(right) {
+  return Cartesian2.equals(this, right);
+};
+Cartesian2.prototype.equalsEpsilon = function(right, relativeEpsilon, absoluteEpsilon) {
+  return Cartesian2.equalsEpsilon(
+    this,
+    right,
+    relativeEpsilon,
+    absoluteEpsilon
+  );
+};
+Cartesian2.prototype.toString = function() {
+  return `(${this.x}, ${this.y})`;
+};
+var Cartesian2_default = Cartesian2;
+
 // packages/engine/Source/Core/Ellipsoid.js
 function initialize(ellipsoid, x, y, z) {
   x = defaultValue_default(x, 0);
@@ -1096,6 +1392,29 @@ Ellipsoid.prototype.getSurfaceNormalIntersectionWithZAxis = function(position, b
   }
   return result;
 };
+var scratchEndpoint = new Cartesian3_default();
+Ellipsoid.prototype.getLocalCurvature = function(surfacePosition, result) {
+  Check_default.typeOf.object("surfacePosition", surfacePosition);
+  if (!defined_default(result)) {
+    result = new Cartesian2_default();
+  }
+  const primeVerticalEndpoint = this.getSurfaceNormalIntersectionWithZAxis(
+    surfacePosition,
+    0,
+    scratchEndpoint
+  );
+  const primeVerticalRadius = Cartesian3_default.distance(
+    surfacePosition,
+    primeVerticalEndpoint
+  );
+  const radiusRatio = this.minimumRadius * primeVerticalRadius / this.maximumRadius ** 2;
+  const meridionalRadius = primeVerticalRadius * radiusRatio ** 2;
+  return Cartesian2_default.fromElements(
+    1 / primeVerticalRadius,
+    1 / meridionalRadius,
+    result
+  );
+};
 var abscissas = [
   0.14887433898163,
   0.43339539412925,
@@ -2036,6 +2355,7 @@ var Matrix3_default = Matrix3;
 export {
   Cartesian3_default,
   Cartographic_default,
+  Cartesian2_default,
   Ellipsoid_default,
   Matrix3_default
 };

package/Build/Workers/{chunk-4EYB62WJ.js → chunk-LGL4P5KL.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.113
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -26,20 +26,20 @@
 import {
   Cartesian4_default,
   Matrix4_default
-} from "./chunk-RSWBNJPT.js";
+} from "./chunk-3PW6ZBN4.js";
 import {
   Cartesian3_default
-} from "./chunk-PHQVHDVI.js";
+} from "./chunk-LGJUI2CE.js";
 import {
   Math_default
-} from "./chunk-IZED7ODV.js";
+} from "./chunk-BP467WX3.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-7FEGZO3D.js";
+} from "./chunk-5HLGKKG3.js";
 import {
   defined_default
-} from "./chunk-YS4KPNLC.js";
+} from "./chunk-YBKFS53K.js";
 
 // packages/engine/Source/Core/Plane.js
 function Plane(normal, distance) {