@cesium/engine 6.1.1 → 7.0.0

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

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.114
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,17 +25,17 @@
 
 import {
   Math_default
-} from "./chunk-IZED7ODV.js";
+} from "./chunk-RV7ZYPFT.js";
 import {
   defaultValue_default
-} from "./chunk-C53JYYKX.js";
+} from "./chunk-5M3U6ZMA.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-7FEGZO3D.js";
+} from "./chunk-S4MAZ3SS.js";
 import {
   defined_default
-} from "./chunk-YS4KPNLC.js";
+} from "./chunk-UGK3FCDY.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-D325WRAY.js → chunk-7XEAYGZK.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.114
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -23,32 +23,38 @@
  * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
  */
 
-import {
-  oneTimeWarning_default
-} from "./chunk-7ONRI7T4.js";
 import {
   PolylinePipeline_default
-} from "./chunk-3FCUUN6M.js";
+} from "./chunk-JCNXK6EL.js";
 import {
   EllipsoidTangentPlane_default
-} from "./chunk-MOLGJDJV.js";
+} from "./chunk-PNBGBETF.js";
 import {
   Quaternion_default,
   Transforms_default
-} from "./chunk-D4YHO4NZ.js";
+} from "./chunk-F6SE42BK.js";
 import {
-  Cartesian2_default,
   Cartesian4_default,
   Matrix4_default
-} from "./chunk-RSWBNJPT.js";
+} from "./chunk-QZAD5O7I.js";
 import {
+  Cartesian2_default,
   Cartesian3_default,
   Cartographic_default,
   Matrix3_default
-} from "./chunk-PHQVHDVI.js";
+} from "./chunk-72SANQJV.js";
 import {
   Math_default
-} from "./chunk-IZED7ODV.js";
+} from "./chunk-RV7ZYPFT.js";
+import {
+  defaultValue_default
+} from "./chunk-5M3U6ZMA.js";
+import {
+  DeveloperError_default
+} from "./chunk-S4MAZ3SS.js";
+import {
+  defined_default
+} from "./chunk-UGK3FCDY.js";
 
 // packages/engine/Source/Core/CornerType.js
 var CornerType = {
@@ -79,6 +85,23 @@ var CornerType = {
 };
 var CornerType_default = Object.freeze(CornerType);
 
+// packages/engine/Source/Core/oneTimeWarning.js
+var warnings = {};
+function oneTimeWarning(identifier, message) {
+  if (!defined_default(identifier)) {
+    throw new DeveloperError_default("identifier is required.");
+  }
+  if (!defined_default(warnings[identifier])) {
+    warnings[identifier] = true;
+    console.warn(defaultValue_default(message, identifier));
+  }
+}
+oneTimeWarning.geometryOutlines = "Entity geometry outlines are unsupported on terrain. Outlines will be disabled. To enable outlines, disable geometry terrain clamping by explicitly setting height to 0.";
+oneTimeWarning.geometryZIndex = "Entity geometry with zIndex are unsupported when height or extrudedHeight are defined.  zIndex will be ignored";
+oneTimeWarning.geometryHeightReference = "Entity corridor, ellipse, polygon or rectangle with heightReference must also have a defined height.  heightReference will be ignored";
+oneTimeWarning.geometryExtrudedHeightReference = "Entity corridor, ellipse, polygon or rectangle with extrudedHeightReference must also have a defined extrudedHeight.  extrudedHeightReference will be ignored";
+var oneTimeWarning_default = oneTimeWarning;
+
 // packages/engine/Source/Core/PolylineVolumeGeometryLibrary.js
 var scratch2Array = [new Cartesian3_default(), new Cartesian3_default()];
 var scratchCartesian1 = new Cartesian3_default();
@@ -665,5 +688,6 @@ var PolylineVolumeGeometryLibrary_default = PolylineVolumeGeometryLibrary;
 
 export {
   CornerType_default,
+  oneTimeWarning_default,
   PolylineVolumeGeometryLibrary_default
 };

package/Build/Workers/{chunk-FGUP2QEP.js → chunk-AIPU2VSX.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.114
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,19 +25,19 @@
 
 import {
   Intersect_default
-} from "./chunk-D4YHO4NZ.js";
+} from "./chunk-F6SE42BK.js";
 import {
   Cartesian3_default
-} from "./chunk-PHQVHDVI.js";
+} from "./chunk-72SANQJV.js";
 import {
   defaultValue_default
-} from "./chunk-C53JYYKX.js";
+} from "./chunk-5M3U6ZMA.js";
 import {
   Check_default
-} from "./chunk-7FEGZO3D.js";
+} from "./chunk-S4MAZ3SS.js";
 import {
   defined_default
-} from "./chunk-YS4KPNLC.js";
+} from "./chunk-UGK3FCDY.js";
 
 // packages/engine/Source/Core/AxisAlignedBoundingBox.js
 function AxisAlignedBoundingBox(minimum, maximum, center) {

package/Build/Workers/{chunk-QUXSQQEF.js → chunk-AR5DNBJ4.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.114
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,19 +25,19 @@
 
 import {
   FeatureDetection_default
-} from "./chunk-D4YHO4NZ.js";
+} from "./chunk-F6SE42BK.js";
 import {
   Math_default
-} from "./chunk-IZED7ODV.js";
+} from "./chunk-RV7ZYPFT.js";
 import {
   defaultValue_default
-} from "./chunk-C53JYYKX.js";
+} from "./chunk-5M3U6ZMA.js";
 import {
   Check_default
-} from "./chunk-7FEGZO3D.js";
+} from "./chunk-S4MAZ3SS.js";
 import {
   defined_default
-} from "./chunk-YS4KPNLC.js";
+} from "./chunk-UGK3FCDY.js";
 
 // packages/engine/Source/Core/Color.js
 function hue2rgb(m1, m2, h) {

package/Build/Workers/{chunk-ZVUAJKAL.js → chunk-BZP4T2JJ.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.114
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,40 +25,38 @@
 
 import {
   EllipsoidRhumbLine_default
-} from "./chunk-6PWSSCRA.js";
+} from "./chunk-OVLG3FRS.js";
 import {
   GeometryAttribute_default,
   Geometry_default,
   PrimitiveType_default
-} from "./chunk-OTBRPBCC.js";
-import {
-  Cartesian2_default
-} from "./chunk-RSWBNJPT.js";
+} from "./chunk-JY5YEZFA.js";
 import {
   ComponentDatatype_default
-} from "./chunk-Z6LPXA7S.js";
+} from "./chunk-GEJTYLCO.js";
 import {
+  Cartesian2_default,
   Cartesian3_default,
   Cartographic_default,
   Ellipsoid_default
-} from "./chunk-PHQVHDVI.js";
+} from "./chunk-72SANQJV.js";
 import {
   Math_default
-} from "./chunk-IZED7ODV.js";
+} from "./chunk-RV7ZYPFT.js";
 import {
   WebGLConstants_default
-} from "./chunk-VNRUVNIK.js";
+} from "./chunk-6HZQPRUS.js";
 import {
   defaultValue_default
-} from "./chunk-C53JYYKX.js";
+} from "./chunk-5M3U6ZMA.js";
 import {
   Check_default
-} from "./chunk-7FEGZO3D.js";
+} from "./chunk-S4MAZ3SS.js";
 import {
   __commonJS,
   __toESM,
   defined_default
-} from "./chunk-YS4KPNLC.js";
+} from "./chunk-UGK3FCDY.js";
 
 // node_modules/earcut/src/earcut.js
 var require_earcut = __commonJS({

package/Build/Workers/{chunk-K6Q5IRBK.js → chunk-DTAIXKTO.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.112
+ * Version 1.114
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -27,19 +27,19 @@ import {
   Cartesian3_default,
   Cartographic_default,
   Ellipsoid_default
-} from "./chunk-PHQVHDVI.js";
+} from "./chunk-72SANQJV.js";
 import {
   Math_default
-} from "./chunk-IZED7ODV.js";
+} from "./chunk-RV7ZYPFT.js";
 import {
   defaultValue_default
-} from "./chunk-C53JYYKX.js";
+} from "./chunk-5M3U6ZMA.js";
 import {
   DeveloperError_default
-} from "./chunk-7FEGZO3D.js";
+} from "./chunk-S4MAZ3SS.js";
 import {
   defined_default
-} from "./chunk-YS4KPNLC.js";
+} from "./chunk-UGK3FCDY.js";
 
 // packages/engine/Source/Core/WebMercatorProjection.js
 function WebMercatorProjection(ellipsoid) {