upload application

public/assets/cesium/Workers/chunk-2LOWCAMW.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  EllipseGeometryLibrary_default
+} from "./chunk-JISPSEF3.js";
+import {
+  GeometryOffsetAttribute_default
+} from "./chunk-GBT7MJ6X.js";
+import {
+  IndexDatatype_default
+} from "./chunk-C4WPMOKT.js";
+import {
+  GeometryAttributes_default
+} from "./chunk-X7IQYYHF.js";
+import {
+  GeometryAttribute_default,
+  Geometry_default,
+  PrimitiveType_default
+} from "./chunk-JXVLNVXC.js";
+import {
+  BoundingSphere_default
+} from "./chunk-KHZNBFOH.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian3_default,
+  Ellipsoid_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import {
+  defaultValue_default
+} from "./chunk-U5HSOKPQ.js";
+import {
+  DeveloperError_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/EllipseOutlineGeometry.js
+var scratchCartesian1 = new Cartesian3_default();
+var boundingSphereCenter = new Cartesian3_default();
+function computeEllipse(options) {
+  const center = options.center;
+  boundingSphereCenter = Cartesian3_default.multiplyByScalar(
+    options.ellipsoid.geodeticSurfaceNormal(center, boundingSphereCenter),
+    options.height,
+    boundingSphereCenter
+  );
+  boundingSphereCenter = Cartesian3_default.add(
+    center,
+    boundingSphereCenter,
+    boundingSphereCenter
+  );
+  const boundingSphere = new BoundingSphere_default(
+    boundingSphereCenter,
+    options.semiMajorAxis
+  );
+  const positions = EllipseGeometryLibrary_default.computeEllipsePositions(
+    options,
+    false,
+    true
+  ).outerPositions;
+  const attributes = new GeometryAttributes_default({
+    position: new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.DOUBLE,
+      componentsPerAttribute: 3,
+      values: EllipseGeometryLibrary_default.raisePositionsToHeight(
+        positions,
+        options,
+        false
+      )
+    })
+  });
+  const length = positions.length / 3;
+  const indices = IndexDatatype_default.createTypedArray(length, length * 2);
+  let index = 0;
+  for (let i = 0; i < length; ++i) {
+    indices[index++] = i;
+    indices[index++] = (i + 1) % length;
+  }
+  return {
+    boundingSphere,
+    attributes,
+    indices
+  };
+}
+var topBoundingSphere = new BoundingSphere_default();
+var bottomBoundingSphere = new BoundingSphere_default();
+function computeExtrudedEllipse(options) {
+  const center = options.center;
+  const ellipsoid = options.ellipsoid;
+  const semiMajorAxis = options.semiMajorAxis;
+  let scaledNormal = Cartesian3_default.multiplyByScalar(
+    ellipsoid.geodeticSurfaceNormal(center, scratchCartesian1),
+    options.height,
+    scratchCartesian1
+  );
+  topBoundingSphere.center = Cartesian3_default.add(
+    center,
+    scaledNormal,
+    topBoundingSphere.center
+  );
+  topBoundingSphere.radius = semiMajorAxis;
+  scaledNormal = Cartesian3_default.multiplyByScalar(
+    ellipsoid.geodeticSurfaceNormal(center, scaledNormal),
+    options.extrudedHeight,
+    scaledNormal
+  );
+  bottomBoundingSphere.center = Cartesian3_default.add(
+    center,
+    scaledNormal,
+    bottomBoundingSphere.center
+  );
+  bottomBoundingSphere.radius = semiMajorAxis;
+  let positions = EllipseGeometryLibrary_default.computeEllipsePositions(
+    options,
+    false,
+    true
+  ).outerPositions;
+  const attributes = new GeometryAttributes_default({
+    position: new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.DOUBLE,
+      componentsPerAttribute: 3,
+      values: EllipseGeometryLibrary_default.raisePositionsToHeight(
+        positions,
+        options,
+        true
+      )
+    })
+  });
+  positions = attributes.position.values;
+  const boundingSphere = BoundingSphere_default.union(
+    topBoundingSphere,
+    bottomBoundingSphere
+  );
+  let length = positions.length / 3;
+  if (defined_default(options.offsetAttribute)) {
+    let applyOffset = new Uint8Array(length);
+    if (options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
+      applyOffset = applyOffset.fill(1, 0, length / 2);
+    } else {
+      const offsetValue = options.offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+      applyOffset = applyOffset.fill(offsetValue);
+    }
+    attributes.applyOffset = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: applyOffset
+    });
+  }
+  let numberOfVerticalLines = defaultValue_default(options.numberOfVerticalLines, 16);
+  numberOfVerticalLines = Math_default.clamp(
+    numberOfVerticalLines,
+    0,
+    length / 2
+  );
+  const indices = IndexDatatype_default.createTypedArray(
+    length,
+    length * 2 + numberOfVerticalLines * 2
+  );
+  length /= 2;
+  let index = 0;
+  let i;
+  for (i = 0; i < length; ++i) {
+    indices[index++] = i;
+    indices[index++] = (i + 1) % length;
+    indices[index++] = i + length;
+    indices[index++] = (i + 1) % length + length;
+  }
+  let numSide;
+  if (numberOfVerticalLines > 0) {
+    const numSideLines = Math.min(numberOfVerticalLines, length);
+    numSide = Math.round(length / numSideLines);
+    const maxI = Math.min(numSide * numberOfVerticalLines, length);
+    for (i = 0; i < maxI; i += numSide) {
+      indices[index++] = i;
+      indices[index++] = i + length;
+    }
+  }
+  return {
+    boundingSphere,
+    attributes,
+    indices
+  };
+}
+function EllipseOutlineGeometry(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const center = options.center;
+  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.default);
+  const semiMajorAxis = options.semiMajorAxis;
+  const semiMinorAxis = options.semiMinorAxis;
+  const granularity = defaultValue_default(
+    options.granularity,
+    Math_default.RADIANS_PER_DEGREE
+  );
+  if (!defined_default(center)) {
+    throw new DeveloperError_default("center is required.");
+  }
+  if (!defined_default(semiMajorAxis)) {
+    throw new DeveloperError_default("semiMajorAxis is required.");
+  }
+  if (!defined_default(semiMinorAxis)) {
+    throw new DeveloperError_default("semiMinorAxis is required.");
+  }
+  if (semiMajorAxis < semiMinorAxis) {
+    throw new DeveloperError_default(
+      "semiMajorAxis must be greater than or equal to the semiMinorAxis."
+    );
+  }
+  if (granularity <= 0) {
+    throw new DeveloperError_default("granularity must be greater than zero.");
+  }
+  const height = defaultValue_default(options.height, 0);
+  const extrudedHeight = defaultValue_default(options.extrudedHeight, height);
+  this._center = Cartesian3_default.clone(center);
+  this._semiMajorAxis = semiMajorAxis;
+  this._semiMinorAxis = semiMinorAxis;
+  this._ellipsoid = Ellipsoid_default.clone(ellipsoid);
+  this._rotation = defaultValue_default(options.rotation, 0);
+  this._height = Math.max(extrudedHeight, height);
+  this._granularity = granularity;
+  this._extrudedHeight = Math.min(extrudedHeight, height);
+  this._numberOfVerticalLines = Math.max(
+    defaultValue_default(options.numberOfVerticalLines, 16),
+    0
+  );
+  this._offsetAttribute = options.offsetAttribute;
+  this._workerName = "createEllipseOutlineGeometry";
+}
+EllipseOutlineGeometry.packedLength = Cartesian3_default.packedLength + Ellipsoid_default.packedLength + 8;
+EllipseOutlineGeometry.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 = defaultValue_default(startingIndex, 0);
+  Cartesian3_default.pack(value._center, array, startingIndex);
+  startingIndex += Cartesian3_default.packedLength;
+  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
+  startingIndex += Ellipsoid_default.packedLength;
+  array[startingIndex++] = value._semiMajorAxis;
+  array[startingIndex++] = value._semiMinorAxis;
+  array[startingIndex++] = value._rotation;
+  array[startingIndex++] = value._height;
+  array[startingIndex++] = value._granularity;
+  array[startingIndex++] = value._extrudedHeight;
+  array[startingIndex++] = value._numberOfVerticalLines;
+  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
+  return array;
+};
+var scratchCenter = new Cartesian3_default();
+var scratchEllipsoid = new Ellipsoid_default();
+var scratchOptions = {
+  center: scratchCenter,
+  ellipsoid: scratchEllipsoid,
+  semiMajorAxis: void 0,
+  semiMinorAxis: void 0,
+  rotation: void 0,
+  height: void 0,
+  granularity: void 0,
+  extrudedHeight: void 0,
+  numberOfVerticalLines: void 0,
+  offsetAttribute: void 0
+};
+EllipseOutlineGeometry.unpack = function(array, startingIndex, result) {
+  if (!defined_default(array)) {
+    throw new DeveloperError_default("array is required");
+  }
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const center = Cartesian3_default.unpack(array, startingIndex, scratchCenter);
+  startingIndex += Cartesian3_default.packedLength;
+  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
+  startingIndex += Ellipsoid_default.packedLength;
+  const semiMajorAxis = array[startingIndex++];
+  const semiMinorAxis = array[startingIndex++];
+  const rotation = array[startingIndex++];
+  const height = array[startingIndex++];
+  const granularity = array[startingIndex++];
+  const extrudedHeight = array[startingIndex++];
+  const numberOfVerticalLines = array[startingIndex++];
+  const offsetAttribute = array[startingIndex];
+  if (!defined_default(result)) {
+    scratchOptions.height = height;
+    scratchOptions.extrudedHeight = extrudedHeight;
+    scratchOptions.granularity = granularity;
+    scratchOptions.rotation = rotation;
+    scratchOptions.semiMajorAxis = semiMajorAxis;
+    scratchOptions.semiMinorAxis = semiMinorAxis;
+    scratchOptions.numberOfVerticalLines = numberOfVerticalLines;
+    scratchOptions.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+    return new EllipseOutlineGeometry(scratchOptions);
+  }
+  result._center = Cartesian3_default.clone(center, result._center);
+  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
+  result._semiMajorAxis = semiMajorAxis;
+  result._semiMinorAxis = semiMinorAxis;
+  result._rotation = rotation;
+  result._height = height;
+  result._granularity = granularity;
+  result._extrudedHeight = extrudedHeight;
+  result._numberOfVerticalLines = numberOfVerticalLines;
+  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+  return result;
+};
+EllipseOutlineGeometry.createGeometry = function(ellipseGeometry) {
+  if (ellipseGeometry._semiMajorAxis <= 0 || ellipseGeometry._semiMinorAxis <= 0) {
+    return;
+  }
+  const height = ellipseGeometry._height;
+  const extrudedHeight = ellipseGeometry._extrudedHeight;
+  const extrude = !Math_default.equalsEpsilon(
+    height,
+    extrudedHeight,
+    0,
+    Math_default.EPSILON2
+  );
+  ellipseGeometry._center = ellipseGeometry._ellipsoid.scaleToGeodeticSurface(
+    ellipseGeometry._center,
+    ellipseGeometry._center
+  );
+  const options = {
+    center: ellipseGeometry._center,
+    semiMajorAxis: ellipseGeometry._semiMajorAxis,
+    semiMinorAxis: ellipseGeometry._semiMinorAxis,
+    ellipsoid: ellipseGeometry._ellipsoid,
+    rotation: ellipseGeometry._rotation,
+    height,
+    granularity: ellipseGeometry._granularity,
+    numberOfVerticalLines: ellipseGeometry._numberOfVerticalLines
+  };
+  let geometry;
+  if (extrude) {
+    options.extrudedHeight = extrudedHeight;
+    options.offsetAttribute = ellipseGeometry._offsetAttribute;
+    geometry = computeExtrudedEllipse(options);
+  } else {
+    geometry = computeEllipse(options);
+    if (defined_default(ellipseGeometry._offsetAttribute)) {
+      const length = geometry.attributes.position.values.length;
+      const offsetValue = ellipseGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+      const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
+      geometry.attributes.applyOffset = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+        componentsPerAttribute: 1,
+        values: applyOffset
+      });
+    }
+  }
+  return new Geometry_default({
+    attributes: geometry.attributes,
+    indices: geometry.indices,
+    primitiveType: PrimitiveType_default.LINES,
+    boundingSphere: geometry.boundingSphere,
+    offsetAttribute: ellipseGeometry._offsetAttribute
+  });
+};
+var EllipseOutlineGeometry_default = EllipseOutlineGeometry;
+
+export {
+  EllipseOutlineGeometry_default
+};

public/assets/cesium/Workers/chunk-2PTKXHJB.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  EllipsoidTangentPlane_default
+} from "./chunk-YK3QIKY7.js";
+import {
+  Plane_default
+} from "./chunk-EDLRS3AW.js";
+import {
+  BoundingSphere_default,
+  Intersect_default,
+  Interval_default
+} from "./chunk-KHZNBFOH.js";
+import {
+  Matrix4_default,
+  Rectangle_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  Cartesian2_default,
+  Cartesian3_default,
+  Cartographic_default,
+  Ellipsoid_default,
+  Matrix3_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import {
+  defaultValue_default
+} from "./chunk-U5HSOKPQ.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/OrientedBoundingBox.js
+function OrientedBoundingBox(center, halfAxes) {
+  this.center = Cartesian3_default.clone(defaultValue_default(center, Cartesian3_default.ZERO));
+  this.halfAxes = Matrix3_default.clone(defaultValue_default(halfAxes, Matrix3_default.ZERO));
+}
+OrientedBoundingBox.packedLength = Cartesian3_default.packedLength + Matrix3_default.packedLength;
+OrientedBoundingBox.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  Cartesian3_default.pack(value.center, array, startingIndex);
+  Matrix3_default.pack(value.halfAxes, array, startingIndex + Cartesian3_default.packedLength);
+  return array;
+};
+OrientedBoundingBox.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  if (!defined_default(result)) {
+    result = new OrientedBoundingBox();
+  }
+  Cartesian3_default.unpack(array, startingIndex, result.center);
+  Matrix3_default.unpack(
+    array,
+    startingIndex + Cartesian3_default.packedLength,
+    result.halfAxes
+  );
+  return result;
+};
+var scratchCartesian1 = new Cartesian3_default();
+var scratchCartesian2 = new Cartesian3_default();
+var scratchCartesian3 = new Cartesian3_default();
+var scratchCartesian4 = new Cartesian3_default();
+var scratchCartesian5 = new Cartesian3_default();
+var scratchCartesian6 = new Cartesian3_default();
+var scratchCovarianceResult = new Matrix3_default();
+var scratchEigenResult = {
+  unitary: new Matrix3_default(),
+  diagonal: new Matrix3_default()
+};
+OrientedBoundingBox.fromPoints = function(positions, result) {
+  if (!defined_default(result)) {
+    result = new OrientedBoundingBox();
+  }
+  if (!defined_default(positions) || positions.length === 0) {
+    result.halfAxes = Matrix3_default.ZERO;
+    result.center = Cartesian3_default.ZERO;
+    return result;
+  }
+  let i;
+  const length = positions.length;
+  const meanPoint = Cartesian3_default.clone(positions[0], scratchCartesian1);
+  for (i = 1; i < length; i++) {
+    Cartesian3_default.add(meanPoint, positions[i], meanPoint);
+  }
+  const invLength = 1 / length;
+  Cartesian3_default.multiplyByScalar(meanPoint, invLength, meanPoint);
+  let exx = 0;
+  let exy = 0;
+  let exz = 0;
+  let eyy = 0;
+  let eyz = 0;
+  let ezz = 0;
+  let p;
+  for (i = 0; i < length; i++) {
+    p = Cartesian3_default.subtract(positions[i], meanPoint, scratchCartesian2);
+    exx += p.x * p.x;
+    exy += p.x * p.y;
+    exz += p.x * p.z;
+    eyy += p.y * p.y;
+    eyz += p.y * p.z;
+    ezz += p.z * p.z;
+  }
+  exx *= invLength;
+  exy *= invLength;
+  exz *= invLength;
+  eyy *= invLength;
+  eyz *= invLength;
+  ezz *= invLength;
+  const covarianceMatrix = scratchCovarianceResult;
+  covarianceMatrix[0] = exx;
+  covarianceMatrix[1] = exy;
+  covarianceMatrix[2] = exz;
+  covarianceMatrix[3] = exy;
+  covarianceMatrix[4] = eyy;
+  covarianceMatrix[5] = eyz;
+  covarianceMatrix[6] = exz;
+  covarianceMatrix[7] = eyz;
+  covarianceMatrix[8] = ezz;
+  const eigenDecomposition = Matrix3_default.computeEigenDecomposition(
+    covarianceMatrix,
+    scratchEigenResult
+  );
+  const rotation = Matrix3_default.clone(eigenDecomposition.unitary, result.halfAxes);
+  let v1 = Matrix3_default.getColumn(rotation, 0, scratchCartesian4);
+  let v2 = Matrix3_default.getColumn(rotation, 1, scratchCartesian5);
+  let v3 = Matrix3_default.getColumn(rotation, 2, scratchCartesian6);
+  let u1 = -Number.MAX_VALUE;
+  let u2 = -Number.MAX_VALUE;
+  let u3 = -Number.MAX_VALUE;
+  let l1 = Number.MAX_VALUE;
+  let l2 = Number.MAX_VALUE;
+  let l3 = Number.MAX_VALUE;
+  for (i = 0; i < length; i++) {
+    p = positions[i];
+    u1 = Math.max(Cartesian3_default.dot(v1, p), u1);
+    u2 = Math.max(Cartesian3_default.dot(v2, p), u2);
+    u3 = Math.max(Cartesian3_default.dot(v3, p), u3);
+    l1 = Math.min(Cartesian3_default.dot(v1, p), l1);
+    l2 = Math.min(Cartesian3_default.dot(v2, p), l2);
+    l3 = Math.min(Cartesian3_default.dot(v3, p), l3);
+  }
+  v1 = Cartesian3_default.multiplyByScalar(v1, 0.5 * (l1 + u1), v1);
+  v2 = Cartesian3_default.multiplyByScalar(v2, 0.5 * (l2 + u2), v2);
+  v3 = Cartesian3_default.multiplyByScalar(v3, 0.5 * (l3 + u3), v3);
+  const center = Cartesian3_default.add(v1, v2, result.center);
+  Cartesian3_default.add(center, v3, center);
+  const scale = scratchCartesian3;
+  scale.x = u1 - l1;
+  scale.y = u2 - l2;
+  scale.z = u3 - l3;
+  Cartesian3_default.multiplyByScalar(scale, 0.5, scale);
+  Matrix3_default.multiplyByScale(result.halfAxes, scale, result.halfAxes);
+  return result;
+};
+var scratchOffset = new Cartesian3_default();
+var scratchScale = new Cartesian3_default();
+function fromPlaneExtents(planeOrigin, planeXAxis, planeYAxis, planeZAxis, minimumX, maximumX, minimumY, maximumY, minimumZ, maximumZ, result) {
+  if (!defined_default(minimumX) || !defined_default(maximumX) || !defined_default(minimumY) || !defined_default(maximumY) || !defined_default(minimumZ) || !defined_default(maximumZ)) {
+    throw new DeveloperError_default(
+      "all extents (minimum/maximum X/Y/Z) are required."
+    );
+  }
+  if (!defined_default(result)) {
+    result = new OrientedBoundingBox();
+  }
+  const halfAxes = result.halfAxes;
+  Matrix3_default.setColumn(halfAxes, 0, planeXAxis, halfAxes);
+  Matrix3_default.setColumn(halfAxes, 1, planeYAxis, halfAxes);
+  Matrix3_default.setColumn(halfAxes, 2, planeZAxis, halfAxes);
+  let centerOffset = scratchOffset;
+  centerOffset.x = (minimumX + maximumX) / 2;
+  centerOffset.y = (minimumY + maximumY) / 2;
+  centerOffset.z = (minimumZ + maximumZ) / 2;
+  const scale = scratchScale;
+  scale.x = (maximumX - minimumX) / 2;
+  scale.y = (maximumY - minimumY) / 2;
+  scale.z = (maximumZ - minimumZ) / 2;
+  const center = result.center;
+  centerOffset = Matrix3_default.multiplyByVector(halfAxes, centerOffset, centerOffset);
+  Cartesian3_default.add(planeOrigin, centerOffset, center);
+  Matrix3_default.multiplyByScale(halfAxes, scale, halfAxes);
+  return result;
+}
+var scratchRectangleCenterCartographic = new Cartographic_default();
+var scratchRectangleCenter = new Cartesian3_default();
+var scratchPerimeterCartographicNC = new Cartographic_default();
+var scratchPerimeterCartographicNW = new Cartographic_default();
+var scratchPerimeterCartographicCW = new Cartographic_default();
+var scratchPerimeterCartographicSW = new Cartographic_default();
+var scratchPerimeterCartographicSC = new Cartographic_default();
+var scratchPerimeterCartesianNC = new Cartesian3_default();
+var scratchPerimeterCartesianNW = new Cartesian3_default();
+var scratchPerimeterCartesianCW = new Cartesian3_default();
+var scratchPerimeterCartesianSW = new Cartesian3_default();
+var scratchPerimeterCartesianSC = new Cartesian3_default();
+var scratchPerimeterProjectedNC = new Cartesian2_default();
+var scratchPerimeterProjectedNW = new Cartesian2_default();
+var scratchPerimeterProjectedCW = new Cartesian2_default();
+var scratchPerimeterProjectedSW = new Cartesian2_default();
+var scratchPerimeterProjectedSC = new Cartesian2_default();
+var scratchPlaneOrigin = new Cartesian3_default();
+var scratchPlaneNormal = new Cartesian3_default();
+var scratchPlaneXAxis = new Cartesian3_default();
+var scratchHorizonCartesian = new Cartesian3_default();
+var scratchHorizonProjected = new Cartesian2_default();
+var scratchMaxY = new Cartesian3_default();
+var scratchMinY = new Cartesian3_default();
+var scratchZ = new Cartesian3_default();
+var scratchPlane = new Plane_default(Cartesian3_default.UNIT_X, 0);
+OrientedBoundingBox.fromRectangle = function(rectangle, minimumHeight, maximumHeight, ellipsoid, result) {
+  if (!defined_default(rectangle)) {
+    throw new DeveloperError_default("rectangle is required");
+  }
+  if (rectangle.width < 0 || rectangle.width > Math_default.TWO_PI) {
+    throw new DeveloperError_default("Rectangle width must be between 0 and 2 * pi");
+  }
+  if (rectangle.height < 0 || rectangle.height > Math_default.PI) {
+    throw new DeveloperError_default("Rectangle height must be between 0 and pi");
+  }
+  if (defined_default(ellipsoid) && !Math_default.equalsEpsilon(
+    ellipsoid.radii.x,
+    ellipsoid.radii.y,
+    Math_default.EPSILON15
+  )) {
+    throw new DeveloperError_default(
+      "Ellipsoid must be an ellipsoid of revolution (radii.x == radii.y)"
+    );
+  }
+  minimumHeight = defaultValue_default(minimumHeight, 0);
+  maximumHeight = defaultValue_default(maximumHeight, 0);
+  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.default);
+  let minX, maxX, minY, maxY, minZ, maxZ, plane;
+  if (rectangle.width <= Math_default.PI) {
+    const tangentPointCartographic = Rectangle_default.center(
+      rectangle,
+      scratchRectangleCenterCartographic
+    );
+    const tangentPoint = ellipsoid.cartographicToCartesian(
+      tangentPointCartographic,
+      scratchRectangleCenter
+    );
+    const tangentPlane = new EllipsoidTangentPlane_default(tangentPoint, ellipsoid);
+    plane = tangentPlane.plane;
+    const lonCenter = tangentPointCartographic.longitude;
+    const latCenter = rectangle.south < 0 && rectangle.north > 0 ? 0 : tangentPointCartographic.latitude;
+    const perimeterCartographicNC = Cartographic_default.fromRadians(
+      lonCenter,
+      rectangle.north,
+      maximumHeight,
+      scratchPerimeterCartographicNC
+    );
+    const perimeterCartographicNW = Cartographic_default.fromRadians(
+      rectangle.west,
+      rectangle.north,
+      maximumHeight,
+      scratchPerimeterCartographicNW
+    );
+    const perimeterCartographicCW = Cartographic_default.fromRadians(
+      rectangle.west,
+      latCenter,
+      maximumHeight,
+      scratchPerimeterCartographicCW
+    );
+    const perimeterCartographicSW = Cartographic_default.fromRadians(
+      rectangle.west,
+      rectangle.south,
+      maximumHeight,
+      scratchPerimeterCartographicSW
+    );
+    const perimeterCartographicSC = Cartographic_default.fromRadians(
+      lonCenter,
+      rectangle.south,
+      maximumHeight,
+      scratchPerimeterCartographicSC
+    );
+    const perimeterCartesianNC = ellipsoid.cartographicToCartesian(
+      perimeterCartographicNC,
+      scratchPerimeterCartesianNC
+    );
+    let perimeterCartesianNW = ellipsoid.cartographicToCartesian(
+      perimeterCartographicNW,
+      scratchPerimeterCartesianNW
+    );
+    const perimeterCartesianCW = ellipsoid.cartographicToCartesian(
+      perimeterCartographicCW,
+      scratchPerimeterCartesianCW
+    );
+    let perimeterCartesianSW = ellipsoid.cartographicToCartesian(
+      perimeterCartographicSW,
+      scratchPerimeterCartesianSW
+    );
+    const perimeterCartesianSC = ellipsoid.cartographicToCartesian(
+      perimeterCartographicSC,
+      scratchPerimeterCartesianSC
+    );
+    const perimeterProjectedNC = tangentPlane.projectPointToNearestOnPlane(
+      perimeterCartesianNC,
+      scratchPerimeterProjectedNC
+    );
+    const perimeterProjectedNW = tangentPlane.projectPointToNearestOnPlane(
+      perimeterCartesianNW,
+      scratchPerimeterProjectedNW
+    );
+    const perimeterProjectedCW = tangentPlane.projectPointToNearestOnPlane(
+      perimeterCartesianCW,
+      scratchPerimeterProjectedCW
+    );
+    const perimeterProjectedSW = tangentPlane.projectPointToNearestOnPlane(
+      perimeterCartesianSW,
+      scratchPerimeterProjectedSW
+    );
+    const perimeterProjectedSC = tangentPlane.projectPointToNearestOnPlane(
+      perimeterCartesianSC,
+      scratchPerimeterProjectedSC
+    );
+    minX = Math.min(
+      perimeterProjectedNW.x,
+      perimeterProjectedCW.x,
+      perimeterProjectedSW.x
+    );
+    maxX = -minX;
+    maxY = Math.max(perimeterProjectedNW.y, perimeterProjectedNC.y);
+    minY = Math.min(perimeterProjectedSW.y, perimeterProjectedSC.y);
+    perimeterCartographicNW.height = perimeterCartographicSW.height = minimumHeight;
+    perimeterCartesianNW = ellipsoid.cartographicToCartesian(
+      perimeterCartographicNW,
+      scratchPerimeterCartesianNW
+    );
+    perimeterCartesianSW = ellipsoid.cartographicToCartesian(
+      perimeterCartographicSW,
+      scratchPerimeterCartesianSW
+    );
+    minZ = Math.min(
+      Plane_default.getPointDistance(plane, perimeterCartesianNW),
+      Plane_default.getPointDistance(plane, perimeterCartesianSW)
+    );
+    maxZ = maximumHeight;
+    return fromPlaneExtents(
+      tangentPlane.origin,
+      tangentPlane.xAxis,
+      tangentPlane.yAxis,
+      tangentPlane.zAxis,
+      minX,
+      maxX,
+      minY,
+      maxY,
+      minZ,
+      maxZ,
+      result
+    );
+  }
+  const fullyAboveEquator = rectangle.south > 0;
+  const fullyBelowEquator = rectangle.north < 0;
+  const latitudeNearestToEquator = fullyAboveEquator ? rectangle.south : fullyBelowEquator ? rectangle.north : 0;
+  const centerLongitude = Rectangle_default.center(
+    rectangle,
+    scratchRectangleCenterCartographic
+  ).longitude;
+  const planeOrigin = Cartesian3_default.fromRadians(
+    centerLongitude,
+    latitudeNearestToEquator,
+    maximumHeight,
+    ellipsoid,
+    scratchPlaneOrigin
+  );
+  planeOrigin.z = 0;
+  const isPole = Math.abs(planeOrigin.x) < Math_default.EPSILON10 && Math.abs(planeOrigin.y) < Math_default.EPSILON10;
+  const planeNormal = !isPole ? Cartesian3_default.normalize(planeOrigin, scratchPlaneNormal) : Cartesian3_default.UNIT_X;
+  const planeYAxis = Cartesian3_default.UNIT_Z;
+  const planeXAxis = Cartesian3_default.cross(
+    planeNormal,
+    planeYAxis,
+    scratchPlaneXAxis
+  );
+  plane = Plane_default.fromPointNormal(planeOrigin, planeNormal, scratchPlane);
+  const horizonCartesian = Cartesian3_default.fromRadians(
+    centerLongitude + Math_default.PI_OVER_TWO,
+    latitudeNearestToEquator,
+    maximumHeight,
+    ellipsoid,
+    scratchHorizonCartesian
+  );
+  maxX = Cartesian3_default.dot(
+    Plane_default.projectPointOntoPlane(
+      plane,
+      horizonCartesian,
+      scratchHorizonProjected
+    ),
+    planeXAxis
+  );
+  minX = -maxX;
+  maxY = Cartesian3_default.fromRadians(
+    0,
+    rectangle.north,
+    fullyBelowEquator ? minimumHeight : maximumHeight,
+    ellipsoid,
+    scratchMaxY
+  ).z;
+  minY = Cartesian3_default.fromRadians(
+    0,
+    rectangle.south,
+    fullyAboveEquator ? minimumHeight : maximumHeight,
+    ellipsoid,
+    scratchMinY
+  ).z;
+  const farZ = Cartesian3_default.fromRadians(
+    rectangle.east,
+    latitudeNearestToEquator,
+    maximumHeight,
+    ellipsoid,
+    scratchZ
+  );
+  minZ = Plane_default.getPointDistance(plane, farZ);
+  maxZ = 0;
+  return fromPlaneExtents(
+    planeOrigin,
+    planeXAxis,
+    planeYAxis,
+    planeNormal,
+    minX,
+    maxX,
+    minY,
+    maxY,
+    minZ,
+    maxZ,
+    result
+  );
+};
+OrientedBoundingBox.fromTransformation = function(transformation, result) {
+  Check_default.typeOf.object("transformation", transformation);
+  if (!defined_default(result)) {
+    result = new OrientedBoundingBox();
+  }
+  result.center = Matrix4_default.getTranslation(transformation, result.center);
+  result.halfAxes = Matrix4_default.getMatrix3(transformation, result.halfAxes);
+  result.halfAxes = Matrix3_default.multiplyByScalar(
+    result.halfAxes,
+    0.5,
+    result.halfAxes
+  );
+  return result;
+};
+OrientedBoundingBox.clone = function(box, result) {
+  if (!defined_default(box)) {
+    return void 0;
+  }
+  if (!defined_default(result)) {
+    return new OrientedBoundingBox(box.center, box.halfAxes);
+  }
+  Cartesian3_default.clone(box.center, result.center);
+  Matrix3_default.clone(box.halfAxes, result.halfAxes);
+  return result;
+};
+OrientedBoundingBox.intersectPlane = function(box, plane) {
+  if (!defined_default(box)) {
+    throw new DeveloperError_default("box is required.");
+  }
+  if (!defined_default(plane)) {
+    throw new DeveloperError_default("plane is required.");
+  }
+  const center = box.center;
+  const normal = plane.normal;
+  const halfAxes = box.halfAxes;
+  const normalX = normal.x, normalY = normal.y, normalZ = normal.z;
+  const radEffective = Math.abs(
+    normalX * halfAxes[Matrix3_default.COLUMN0ROW0] + normalY * halfAxes[Matrix3_default.COLUMN0ROW1] + normalZ * halfAxes[Matrix3_default.COLUMN0ROW2]
+  ) + Math.abs(
+    normalX * halfAxes[Matrix3_default.COLUMN1ROW0] + normalY * halfAxes[Matrix3_default.COLUMN1ROW1] + normalZ * halfAxes[Matrix3_default.COLUMN1ROW2]
+  ) + Math.abs(
+    normalX * halfAxes[Matrix3_default.COLUMN2ROW0] + normalY * halfAxes[Matrix3_default.COLUMN2ROW1] + normalZ * halfAxes[Matrix3_default.COLUMN2ROW2]
+  );
+  const distanceToPlane = Cartesian3_default.dot(normal, center) + plane.distance;
+  if (distanceToPlane <= -radEffective) {
+    return Intersect_default.OUTSIDE;
+  } else if (distanceToPlane >= radEffective) {
+    return Intersect_default.INSIDE;
+  }
+  return Intersect_default.INTERSECTING;
+};
+var scratchCartesianU = new Cartesian3_default();
+var scratchCartesianV = new Cartesian3_default();
+var scratchCartesianW = new Cartesian3_default();
+var scratchValidAxis2 = new Cartesian3_default();
+var scratchValidAxis3 = new Cartesian3_default();
+var scratchPPrime = new Cartesian3_default();
+OrientedBoundingBox.distanceSquaredTo = function(box, cartesian) {
+  if (!defined_default(box)) {
+    throw new DeveloperError_default("box is required.");
+  }
+  if (!defined_default(cartesian)) {
+    throw new DeveloperError_default("cartesian is required.");
+  }
+  const offset = Cartesian3_default.subtract(cartesian, box.center, scratchOffset);
+  const halfAxes = box.halfAxes;
+  let u = Matrix3_default.getColumn(halfAxes, 0, scratchCartesianU);
+  let v = Matrix3_default.getColumn(halfAxes, 1, scratchCartesianV);
+  let w = Matrix3_default.getColumn(halfAxes, 2, scratchCartesianW);
+  const uHalf = Cartesian3_default.magnitude(u);
+  const vHalf = Cartesian3_default.magnitude(v);
+  const wHalf = Cartesian3_default.magnitude(w);
+  let uValid = true;
+  let vValid = true;
+  let wValid = true;
+  if (uHalf > 0) {
+    Cartesian3_default.divideByScalar(u, uHalf, u);
+  } else {
+    uValid = false;
+  }
+  if (vHalf > 0) {
+    Cartesian3_default.divideByScalar(v, vHalf, v);
+  } else {
+    vValid = false;
+  }
+  if (wHalf > 0) {
+    Cartesian3_default.divideByScalar(w, wHalf, w);
+  } else {
+    wValid = false;
+  }
+  const numberOfDegenerateAxes = !uValid + !vValid + !wValid;
+  let validAxis1;
+  let validAxis2;
+  let validAxis3;
+  if (numberOfDegenerateAxes === 1) {
+    let degenerateAxis = u;
+    validAxis1 = v;
+    validAxis2 = w;
+    if (!vValid) {
+      degenerateAxis = v;
+      validAxis1 = u;
+    } else if (!wValid) {
+      degenerateAxis = w;
+      validAxis2 = u;
+    }
+    validAxis3 = Cartesian3_default.cross(validAxis1, validAxis2, scratchValidAxis3);
+    if (degenerateAxis === u) {
+      u = validAxis3;
+    } else if (degenerateAxis === v) {
+      v = validAxis3;
+    } else if (degenerateAxis === w) {
+      w = validAxis3;
+    }
+  } else if (numberOfDegenerateAxes === 2) {
+    validAxis1 = u;
+    if (vValid) {
+      validAxis1 = v;
+    } else if (wValid) {
+      validAxis1 = w;
+    }
+    let crossVector = Cartesian3_default.UNIT_Y;
+    if (crossVector.equalsEpsilon(validAxis1, Math_default.EPSILON3)) {
+      crossVector = Cartesian3_default.UNIT_X;
+    }
+    validAxis2 = Cartesian3_default.cross(validAxis1, crossVector, scratchValidAxis2);
+    Cartesian3_default.normalize(validAxis2, validAxis2);
+    validAxis3 = Cartesian3_default.cross(validAxis1, validAxis2, scratchValidAxis3);
+    Cartesian3_default.normalize(validAxis3, validAxis3);
+    if (validAxis1 === u) {
+      v = validAxis2;
+      w = validAxis3;
+    } else if (validAxis1 === v) {
+      w = validAxis2;
+      u = validAxis3;
+    } else if (validAxis1 === w) {
+      u = validAxis2;
+      v = validAxis3;
+    }
+  } else if (numberOfDegenerateAxes === 3) {
+    u = Cartesian3_default.UNIT_X;
+    v = Cartesian3_default.UNIT_Y;
+    w = Cartesian3_default.UNIT_Z;
+  }
+  const pPrime = scratchPPrime;
+  pPrime.x = Cartesian3_default.dot(offset, u);
+  pPrime.y = Cartesian3_default.dot(offset, v);
+  pPrime.z = Cartesian3_default.dot(offset, w);
+  let distanceSquared = 0;
+  let d;
+  if (pPrime.x < -uHalf) {
+    d = pPrime.x + uHalf;
+    distanceSquared += d * d;
+  } else if (pPrime.x > uHalf) {
+    d = pPrime.x - uHalf;
+    distanceSquared += d * d;
+  }
+  if (pPrime.y < -vHalf) {
+    d = pPrime.y + vHalf;
+    distanceSquared += d * d;
+  } else if (pPrime.y > vHalf) {
+    d = pPrime.y - vHalf;
+    distanceSquared += d * d;
+  }
+  if (pPrime.z < -wHalf) {
+    d = pPrime.z + wHalf;
+    distanceSquared += d * d;
+  } else if (pPrime.z > wHalf) {
+    d = pPrime.z - wHalf;
+    distanceSquared += d * d;
+  }
+  return distanceSquared;
+};
+var scratchCorner = new Cartesian3_default();
+var scratchToCenter = new Cartesian3_default();
+OrientedBoundingBox.computePlaneDistances = function(box, position, direction, result) {
+  if (!defined_default(box)) {
+    throw new DeveloperError_default("box is required.");
+  }
+  if (!defined_default(position)) {
+    throw new DeveloperError_default("position is required.");
+  }
+  if (!defined_default(direction)) {
+    throw new DeveloperError_default("direction is required.");
+  }
+  if (!defined_default(result)) {
+    result = new Interval_default();
+  }
+  let minDist = Number.POSITIVE_INFINITY;
+  let maxDist = Number.NEGATIVE_INFINITY;
+  const center = box.center;
+  const halfAxes = box.halfAxes;
+  const u = Matrix3_default.getColumn(halfAxes, 0, scratchCartesianU);
+  const v = Matrix3_default.getColumn(halfAxes, 1, scratchCartesianV);
+  const w = Matrix3_default.getColumn(halfAxes, 2, scratchCartesianW);
+  const corner = Cartesian3_default.add(u, v, scratchCorner);
+  Cartesian3_default.add(corner, w, corner);
+  Cartesian3_default.add(corner, center, corner);
+  const toCenter = Cartesian3_default.subtract(corner, position, scratchToCenter);
+  let mag = Cartesian3_default.dot(direction, toCenter);
+  minDist = Math.min(mag, minDist);
+  maxDist = Math.max(mag, maxDist);
+  Cartesian3_default.add(center, u, corner);
+  Cartesian3_default.add(corner, v, corner);
+  Cartesian3_default.subtract(corner, w, corner);
+  Cartesian3_default.subtract(corner, position, toCenter);
+  mag = Cartesian3_default.dot(direction, toCenter);
+  minDist = Math.min(mag, minDist);
+  maxDist = Math.max(mag, maxDist);
+  Cartesian3_default.add(center, u, corner);
+  Cartesian3_default.subtract(corner, v, corner);
+  Cartesian3_default.add(corner, w, corner);
+  Cartesian3_default.subtract(corner, position, toCenter);
+  mag = Cartesian3_default.dot(direction, toCenter);
+  minDist = Math.min(mag, minDist);
+  maxDist = Math.max(mag, maxDist);
+  Cartesian3_default.add(center, u, corner);
+  Cartesian3_default.subtract(corner, v, corner);
+  Cartesian3_default.subtract(corner, w, corner);
+  Cartesian3_default.subtract(corner, position, toCenter);
+  mag = Cartesian3_default.dot(direction, toCenter);
+  minDist = Math.min(mag, minDist);
+  maxDist = Math.max(mag, maxDist);
+  Cartesian3_default.subtract(center, u, corner);
+  Cartesian3_default.add(corner, v, corner);
+  Cartesian3_default.add(corner, w, corner);
+  Cartesian3_default.subtract(corner, position, toCenter);
+  mag = Cartesian3_default.dot(direction, toCenter);
+  minDist = Math.min(mag, minDist);
+  maxDist = Math.max(mag, maxDist);
+  Cartesian3_default.subtract(center, u, corner);
+  Cartesian3_default.add(corner, v, corner);
+  Cartesian3_default.subtract(corner, w, corner);
+  Cartesian3_default.subtract(corner, position, toCenter);
+  mag = Cartesian3_default.dot(direction, toCenter);
+  minDist = Math.min(mag, minDist);
+  maxDist = Math.max(mag, maxDist);
+  Cartesian3_default.subtract(center, u, corner);
+  Cartesian3_default.subtract(corner, v, corner);
+  Cartesian3_default.add(corner, w, corner);
+  Cartesian3_default.subtract(corner, position, toCenter);
+  mag = Cartesian3_default.dot(direction, toCenter);
+  minDist = Math.min(mag, minDist);
+  maxDist = Math.max(mag, maxDist);
+  Cartesian3_default.subtract(center, u, corner);
+  Cartesian3_default.subtract(corner, v, corner);
+  Cartesian3_default.subtract(corner, w, corner);
+  Cartesian3_default.subtract(corner, position, toCenter);
+  mag = Cartesian3_default.dot(direction, toCenter);
+  minDist = Math.min(mag, minDist);
+  maxDist = Math.max(mag, maxDist);
+  result.start = minDist;
+  result.stop = maxDist;
+  return result;
+};
+var scratchXAxis = new Cartesian3_default();
+var scratchYAxis = new Cartesian3_default();
+var scratchZAxis = new Cartesian3_default();
+OrientedBoundingBox.computeCorners = function(box, result) {
+  Check_default.typeOf.object("box", box);
+  if (!defined_default(result)) {
+    result = [
+      new Cartesian3_default(),
+      new Cartesian3_default(),
+      new Cartesian3_default(),
+      new Cartesian3_default(),
+      new Cartesian3_default(),
+      new Cartesian3_default(),
+      new Cartesian3_default(),
+      new Cartesian3_default()
+    ];
+  }
+  const center = box.center;
+  const halfAxes = box.halfAxes;
+  const xAxis = Matrix3_default.getColumn(halfAxes, 0, scratchXAxis);
+  const yAxis = Matrix3_default.getColumn(halfAxes, 1, scratchYAxis);
+  const zAxis = Matrix3_default.getColumn(halfAxes, 2, scratchZAxis);
+  Cartesian3_default.clone(center, result[0]);
+  Cartesian3_default.subtract(result[0], xAxis, result[0]);
+  Cartesian3_default.subtract(result[0], yAxis, result[0]);
+  Cartesian3_default.subtract(result[0], zAxis, result[0]);
+  Cartesian3_default.clone(center, result[1]);
+  Cartesian3_default.subtract(result[1], xAxis, result[1]);
+  Cartesian3_default.subtract(result[1], yAxis, result[1]);
+  Cartesian3_default.add(result[1], zAxis, result[1]);
+  Cartesian3_default.clone(center, result[2]);
+  Cartesian3_default.subtract(result[2], xAxis, result[2]);
+  Cartesian3_default.add(result[2], yAxis, result[2]);
+  Cartesian3_default.subtract(result[2], zAxis, result[2]);
+  Cartesian3_default.clone(center, result[3]);
+  Cartesian3_default.subtract(result[3], xAxis, result[3]);
+  Cartesian3_default.add(result[3], yAxis, result[3]);
+  Cartesian3_default.add(result[3], zAxis, result[3]);
+  Cartesian3_default.clone(center, result[4]);
+  Cartesian3_default.add(result[4], xAxis, result[4]);
+  Cartesian3_default.subtract(result[4], yAxis, result[4]);
+  Cartesian3_default.subtract(result[4], zAxis, result[4]);
+  Cartesian3_default.clone(center, result[5]);
+  Cartesian3_default.add(result[5], xAxis, result[5]);
+  Cartesian3_default.subtract(result[5], yAxis, result[5]);
+  Cartesian3_default.add(result[5], zAxis, result[5]);
+  Cartesian3_default.clone(center, result[6]);
+  Cartesian3_default.add(result[6], xAxis, result[6]);
+  Cartesian3_default.add(result[6], yAxis, result[6]);
+  Cartesian3_default.subtract(result[6], zAxis, result[6]);
+  Cartesian3_default.clone(center, result[7]);
+  Cartesian3_default.add(result[7], xAxis, result[7]);
+  Cartesian3_default.add(result[7], yAxis, result[7]);
+  Cartesian3_default.add(result[7], zAxis, result[7]);
+  return result;
+};
+var scratchRotationScale = new Matrix3_default();
+OrientedBoundingBox.computeTransformation = function(box, result) {
+  Check_default.typeOf.object("box", box);
+  if (!defined_default(result)) {
+    result = new Matrix4_default();
+  }
+  const translation = box.center;
+  const rotationScale = Matrix3_default.multiplyByUniformScale(
+    box.halfAxes,
+    2,
+    scratchRotationScale
+  );
+  return Matrix4_default.fromRotationTranslation(rotationScale, translation, result);
+};
+var scratchBoundingSphere = new BoundingSphere_default();
+OrientedBoundingBox.isOccluded = function(box, occluder) {
+  if (!defined_default(box)) {
+    throw new DeveloperError_default("box is required.");
+  }
+  if (!defined_default(occluder)) {
+    throw new DeveloperError_default("occluder is required.");
+  }
+  const sphere = BoundingSphere_default.fromOrientedBoundingBox(
+    box,
+    scratchBoundingSphere
+  );
+  return !occluder.isBoundingSphereVisible(sphere);
+};
+OrientedBoundingBox.prototype.intersectPlane = function(plane) {
+  return OrientedBoundingBox.intersectPlane(this, plane);
+};
+OrientedBoundingBox.prototype.distanceSquaredTo = function(cartesian) {
+  return OrientedBoundingBox.distanceSquaredTo(this, cartesian);
+};
+OrientedBoundingBox.prototype.computePlaneDistances = function(position, direction, result) {
+  return OrientedBoundingBox.computePlaneDistances(
+    this,
+    position,
+    direction,
+    result
+  );
+};
+OrientedBoundingBox.prototype.computeCorners = function(result) {
+  return OrientedBoundingBox.computeCorners(this, result);
+};
+OrientedBoundingBox.prototype.computeTransformation = function(result) {
+  return OrientedBoundingBox.computeTransformation(this, result);
+};
+OrientedBoundingBox.prototype.isOccluded = function(occluder) {
+  return OrientedBoundingBox.isOccluded(this, occluder);
+};
+OrientedBoundingBox.equals = function(left, right) {
+  return left === right || defined_default(left) && defined_default(right) && Cartesian3_default.equals(left.center, right.center) && Matrix3_default.equals(left.halfAxes, right.halfAxes);
+};
+OrientedBoundingBox.prototype.clone = function(result) {
+  return OrientedBoundingBox.clone(this, result);
+};
+OrientedBoundingBox.prototype.equals = function(right) {
+  return OrientedBoundingBox.equals(this, right);
+};
+var OrientedBoundingBox_default = OrientedBoundingBox;
+
+export {
+  OrientedBoundingBox_default
+};

public/assets/cesium/Workers/chunk-3HQMMUPU.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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.
+ */
+
+
+// packages/engine/Source/Core/WebGLConstants.js
+var WebGLConstants = {
+  DEPTH_BUFFER_BIT: 256,
+  STENCIL_BUFFER_BIT: 1024,
+  COLOR_BUFFER_BIT: 16384,
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6,
+  ZERO: 0,
+  ONE: 1,
+  SRC_COLOR: 768,
+  ONE_MINUS_SRC_COLOR: 769,
+  SRC_ALPHA: 770,
+  ONE_MINUS_SRC_ALPHA: 771,
+  DST_ALPHA: 772,
+  ONE_MINUS_DST_ALPHA: 773,
+  DST_COLOR: 774,
+  ONE_MINUS_DST_COLOR: 775,
+  SRC_ALPHA_SATURATE: 776,
+  FUNC_ADD: 32774,
+  BLEND_EQUATION: 32777,
+  BLEND_EQUATION_RGB: 32777,
+  // same as BLEND_EQUATION
+  BLEND_EQUATION_ALPHA: 34877,
+  FUNC_SUBTRACT: 32778,
+  FUNC_REVERSE_SUBTRACT: 32779,
+  BLEND_DST_RGB: 32968,
+  BLEND_SRC_RGB: 32969,
+  BLEND_DST_ALPHA: 32970,
+  BLEND_SRC_ALPHA: 32971,
+  CONSTANT_COLOR: 32769,
+  ONE_MINUS_CONSTANT_COLOR: 32770,
+  CONSTANT_ALPHA: 32771,
+  ONE_MINUS_CONSTANT_ALPHA: 32772,
+  BLEND_COLOR: 32773,
+  ARRAY_BUFFER: 34962,
+  ELEMENT_ARRAY_BUFFER: 34963,
+  ARRAY_BUFFER_BINDING: 34964,
+  ELEMENT_ARRAY_BUFFER_BINDING: 34965,
+  STREAM_DRAW: 35040,
+  STATIC_DRAW: 35044,
+  DYNAMIC_DRAW: 35048,
+  BUFFER_SIZE: 34660,
+  BUFFER_USAGE: 34661,
+  CURRENT_VERTEX_ATTRIB: 34342,
+  FRONT: 1028,
+  BACK: 1029,
+  FRONT_AND_BACK: 1032,
+  CULL_FACE: 2884,
+  BLEND: 3042,
+  DITHER: 3024,
+  STENCIL_TEST: 2960,
+  DEPTH_TEST: 2929,
+  SCISSOR_TEST: 3089,
+  POLYGON_OFFSET_FILL: 32823,
+  SAMPLE_ALPHA_TO_COVERAGE: 32926,
+  SAMPLE_COVERAGE: 32928,
+  NO_ERROR: 0,
+  INVALID_ENUM: 1280,
+  INVALID_VALUE: 1281,
+  INVALID_OPERATION: 1282,
+  OUT_OF_MEMORY: 1285,
+  CW: 2304,
+  CCW: 2305,
+  LINE_WIDTH: 2849,
+  ALIASED_POINT_SIZE_RANGE: 33901,
+  ALIASED_LINE_WIDTH_RANGE: 33902,
+  CULL_FACE_MODE: 2885,
+  FRONT_FACE: 2886,
+  DEPTH_RANGE: 2928,
+  DEPTH_WRITEMASK: 2930,
+  DEPTH_CLEAR_VALUE: 2931,
+  DEPTH_FUNC: 2932,
+  STENCIL_CLEAR_VALUE: 2961,
+  STENCIL_FUNC: 2962,
+  STENCIL_FAIL: 2964,
+  STENCIL_PASS_DEPTH_FAIL: 2965,
+  STENCIL_PASS_DEPTH_PASS: 2966,
+  STENCIL_REF: 2967,
+  STENCIL_VALUE_MASK: 2963,
+  STENCIL_WRITEMASK: 2968,
+  STENCIL_BACK_FUNC: 34816,
+  STENCIL_BACK_FAIL: 34817,
+  STENCIL_BACK_PASS_DEPTH_FAIL: 34818,
+  STENCIL_BACK_PASS_DEPTH_PASS: 34819,
+  STENCIL_BACK_REF: 36003,
+  STENCIL_BACK_VALUE_MASK: 36004,
+  STENCIL_BACK_WRITEMASK: 36005,
+  VIEWPORT: 2978,
+  SCISSOR_BOX: 3088,
+  COLOR_CLEAR_VALUE: 3106,
+  COLOR_WRITEMASK: 3107,
+  UNPACK_ALIGNMENT: 3317,
+  PACK_ALIGNMENT: 3333,
+  MAX_TEXTURE_SIZE: 3379,
+  MAX_VIEWPORT_DIMS: 3386,
+  SUBPIXEL_BITS: 3408,
+  RED_BITS: 3410,
+  GREEN_BITS: 3411,
+  BLUE_BITS: 3412,
+  ALPHA_BITS: 3413,
+  DEPTH_BITS: 3414,
+  STENCIL_BITS: 3415,
+  POLYGON_OFFSET_UNITS: 10752,
+  POLYGON_OFFSET_FACTOR: 32824,
+  TEXTURE_BINDING_2D: 32873,
+  SAMPLE_BUFFERS: 32936,
+  SAMPLES: 32937,
+  SAMPLE_COVERAGE_VALUE: 32938,
+  SAMPLE_COVERAGE_INVERT: 32939,
+  COMPRESSED_TEXTURE_FORMATS: 34467,
+  DONT_CARE: 4352,
+  FASTEST: 4353,
+  NICEST: 4354,
+  GENERATE_MIPMAP_HINT: 33170,
+  BYTE: 5120,
+  UNSIGNED_BYTE: 5121,
+  SHORT: 5122,
+  UNSIGNED_SHORT: 5123,
+  INT: 5124,
+  UNSIGNED_INT: 5125,
+  FLOAT: 5126,
+  DEPTH_COMPONENT: 6402,
+  ALPHA: 6406,
+  RGB: 6407,
+  RGBA: 6408,
+  LUMINANCE: 6409,
+  LUMINANCE_ALPHA: 6410,
+  UNSIGNED_SHORT_4_4_4_4: 32819,
+  UNSIGNED_SHORT_5_5_5_1: 32820,
+  UNSIGNED_SHORT_5_6_5: 33635,
+  FRAGMENT_SHADER: 35632,
+  VERTEX_SHADER: 35633,
+  MAX_VERTEX_ATTRIBS: 34921,
+  MAX_VERTEX_UNIFORM_VECTORS: 36347,
+  MAX_VARYING_VECTORS: 36348,
+  MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661,
+  MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35660,
+  MAX_TEXTURE_IMAGE_UNITS: 34930,
+  MAX_FRAGMENT_UNIFORM_VECTORS: 36349,
+  SHADER_TYPE: 35663,
+  DELETE_STATUS: 35712,
+  LINK_STATUS: 35714,
+  VALIDATE_STATUS: 35715,
+  ATTACHED_SHADERS: 35717,
+  ACTIVE_UNIFORMS: 35718,
+  ACTIVE_ATTRIBUTES: 35721,
+  SHADING_LANGUAGE_VERSION: 35724,
+  CURRENT_PROGRAM: 35725,
+  NEVER: 512,
+  LESS: 513,
+  EQUAL: 514,
+  LEQUAL: 515,
+  GREATER: 516,
+  NOTEQUAL: 517,
+  GEQUAL: 518,
+  ALWAYS: 519,
+  KEEP: 7680,
+  REPLACE: 7681,
+  INCR: 7682,
+  DECR: 7683,
+  INVERT: 5386,
+  INCR_WRAP: 34055,
+  DECR_WRAP: 34056,
+  VENDOR: 7936,
+  RENDERER: 7937,
+  VERSION: 7938,
+  NEAREST: 9728,
+  LINEAR: 9729,
+  NEAREST_MIPMAP_NEAREST: 9984,
+  LINEAR_MIPMAP_NEAREST: 9985,
+  NEAREST_MIPMAP_LINEAR: 9986,
+  LINEAR_MIPMAP_LINEAR: 9987,
+  TEXTURE_MAG_FILTER: 10240,
+  TEXTURE_MIN_FILTER: 10241,
+  TEXTURE_WRAP_S: 10242,
+  TEXTURE_WRAP_T: 10243,
+  TEXTURE_2D: 3553,
+  TEXTURE: 5890,
+  TEXTURE_CUBE_MAP: 34067,
+  TEXTURE_BINDING_CUBE_MAP: 34068,
+  TEXTURE_CUBE_MAP_POSITIVE_X: 34069,
+  TEXTURE_CUBE_MAP_NEGATIVE_X: 34070,
+  TEXTURE_CUBE_MAP_POSITIVE_Y: 34071,
+  TEXTURE_CUBE_MAP_NEGATIVE_Y: 34072,
+  TEXTURE_CUBE_MAP_POSITIVE_Z: 34073,
+  TEXTURE_CUBE_MAP_NEGATIVE_Z: 34074,
+  MAX_CUBE_MAP_TEXTURE_SIZE: 34076,
+  TEXTURE0: 33984,
+  TEXTURE1: 33985,
+  TEXTURE2: 33986,
+  TEXTURE3: 33987,
+  TEXTURE4: 33988,
+  TEXTURE5: 33989,
+  TEXTURE6: 33990,
+  TEXTURE7: 33991,
+  TEXTURE8: 33992,
+  TEXTURE9: 33993,
+  TEXTURE10: 33994,
+  TEXTURE11: 33995,
+  TEXTURE12: 33996,
+  TEXTURE13: 33997,
+  TEXTURE14: 33998,
+  TEXTURE15: 33999,
+  TEXTURE16: 34e3,
+  TEXTURE17: 34001,
+  TEXTURE18: 34002,
+  TEXTURE19: 34003,
+  TEXTURE20: 34004,
+  TEXTURE21: 34005,
+  TEXTURE22: 34006,
+  TEXTURE23: 34007,
+  TEXTURE24: 34008,
+  TEXTURE25: 34009,
+  TEXTURE26: 34010,
+  TEXTURE27: 34011,
+  TEXTURE28: 34012,
+  TEXTURE29: 34013,
+  TEXTURE30: 34014,
+  TEXTURE31: 34015,
+  ACTIVE_TEXTURE: 34016,
+  REPEAT: 10497,
+  CLAMP_TO_EDGE: 33071,
+  MIRRORED_REPEAT: 33648,
+  FLOAT_VEC2: 35664,
+  FLOAT_VEC3: 35665,
+  FLOAT_VEC4: 35666,
+  INT_VEC2: 35667,
+  INT_VEC3: 35668,
+  INT_VEC4: 35669,
+  BOOL: 35670,
+  BOOL_VEC2: 35671,
+  BOOL_VEC3: 35672,
+  BOOL_VEC4: 35673,
+  FLOAT_MAT2: 35674,
+  FLOAT_MAT3: 35675,
+  FLOAT_MAT4: 35676,
+  SAMPLER_2D: 35678,
+  SAMPLER_CUBE: 35680,
+  VERTEX_ATTRIB_ARRAY_ENABLED: 34338,
+  VERTEX_ATTRIB_ARRAY_SIZE: 34339,
+  VERTEX_ATTRIB_ARRAY_STRIDE: 34340,
+  VERTEX_ATTRIB_ARRAY_TYPE: 34341,
+  VERTEX_ATTRIB_ARRAY_NORMALIZED: 34922,
+  VERTEX_ATTRIB_ARRAY_POINTER: 34373,
+  VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 34975,
+  IMPLEMENTATION_COLOR_READ_TYPE: 35738,
+  IMPLEMENTATION_COLOR_READ_FORMAT: 35739,
+  COMPILE_STATUS: 35713,
+  LOW_FLOAT: 36336,
+  MEDIUM_FLOAT: 36337,
+  HIGH_FLOAT: 36338,
+  LOW_INT: 36339,
+  MEDIUM_INT: 36340,
+  HIGH_INT: 36341,
+  FRAMEBUFFER: 36160,
+  RENDERBUFFER: 36161,
+  RGBA4: 32854,
+  RGB5_A1: 32855,
+  RGB565: 36194,
+  DEPTH_COMPONENT16: 33189,
+  STENCIL_INDEX: 6401,
+  STENCIL_INDEX8: 36168,
+  DEPTH_STENCIL: 34041,
+  RENDERBUFFER_WIDTH: 36162,
+  RENDERBUFFER_HEIGHT: 36163,
+  RENDERBUFFER_INTERNAL_FORMAT: 36164,
+  RENDERBUFFER_RED_SIZE: 36176,
+  RENDERBUFFER_GREEN_SIZE: 36177,
+  RENDERBUFFER_BLUE_SIZE: 36178,
+  RENDERBUFFER_ALPHA_SIZE: 36179,
+  RENDERBUFFER_DEPTH_SIZE: 36180,
+  RENDERBUFFER_STENCIL_SIZE: 36181,
+  FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 36048,
+  FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 36049,
+  FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 36050,
+  FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 36051,
+  COLOR_ATTACHMENT0: 36064,
+  DEPTH_ATTACHMENT: 36096,
+  STENCIL_ATTACHMENT: 36128,
+  DEPTH_STENCIL_ATTACHMENT: 33306,
+  NONE: 0,
+  FRAMEBUFFER_COMPLETE: 36053,
+  FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 36054,
+  FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 36055,
+  FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 36057,
+  FRAMEBUFFER_UNSUPPORTED: 36061,
+  FRAMEBUFFER_BINDING: 36006,
+  RENDERBUFFER_BINDING: 36007,
+  MAX_RENDERBUFFER_SIZE: 34024,
+  INVALID_FRAMEBUFFER_OPERATION: 1286,
+  UNPACK_FLIP_Y_WEBGL: 37440,
+  UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441,
+  CONTEXT_LOST_WEBGL: 37442,
+  UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443,
+  BROWSER_DEFAULT_WEBGL: 37444,
+  // WEBGL_compressed_texture_s3tc
+  COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
+  COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
+  COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
+  COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
+  // WEBGL_compressed_texture_pvrtc
+  COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
+  COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
+  COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
+  COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
+  // WEBGL_compressed_texture_astc
+  COMPRESSED_RGBA_ASTC_4x4_WEBGL: 37808,
+  // WEBGL_compressed_texture_etc1
+  COMPRESSED_RGB_ETC1_WEBGL: 36196,
+  // EXT_texture_compression_bptc
+  COMPRESSED_RGBA_BPTC_UNORM: 36492,
+  // EXT_color_buffer_half_float
+  HALF_FLOAT_OES: 36193,
+  // Desktop OpenGL
+  DOUBLE: 5130,
+  // WebGL 2
+  READ_BUFFER: 3074,
+  UNPACK_ROW_LENGTH: 3314,
+  UNPACK_SKIP_ROWS: 3315,
+  UNPACK_SKIP_PIXELS: 3316,
+  PACK_ROW_LENGTH: 3330,
+  PACK_SKIP_ROWS: 3331,
+  PACK_SKIP_PIXELS: 3332,
+  COLOR: 6144,
+  DEPTH: 6145,
+  STENCIL: 6146,
+  RED: 6403,
+  RGB8: 32849,
+  RGBA8: 32856,
+  RGB10_A2: 32857,
+  TEXTURE_BINDING_3D: 32874,
+  UNPACK_SKIP_IMAGES: 32877,
+  UNPACK_IMAGE_HEIGHT: 32878,
+  TEXTURE_3D: 32879,
+  TEXTURE_WRAP_R: 32882,
+  MAX_3D_TEXTURE_SIZE: 32883,
+  UNSIGNED_INT_2_10_10_10_REV: 33640,
+  MAX_ELEMENTS_VERTICES: 33e3,
+  MAX_ELEMENTS_INDICES: 33001,
+  TEXTURE_MIN_LOD: 33082,
+  TEXTURE_MAX_LOD: 33083,
+  TEXTURE_BASE_LEVEL: 33084,
+  TEXTURE_MAX_LEVEL: 33085,
+  MIN: 32775,
+  MAX: 32776,
+  DEPTH_COMPONENT24: 33190,
+  MAX_TEXTURE_LOD_BIAS: 34045,
+  TEXTURE_COMPARE_MODE: 34892,
+  TEXTURE_COMPARE_FUNC: 34893,
+  CURRENT_QUERY: 34917,
+  QUERY_RESULT: 34918,
+  QUERY_RESULT_AVAILABLE: 34919,
+  STREAM_READ: 35041,
+  STREAM_COPY: 35042,
+  STATIC_READ: 35045,
+  STATIC_COPY: 35046,
+  DYNAMIC_READ: 35049,
+  DYNAMIC_COPY: 35050,
+  MAX_DRAW_BUFFERS: 34852,
+  DRAW_BUFFER0: 34853,
+  DRAW_BUFFER1: 34854,
+  DRAW_BUFFER2: 34855,
+  DRAW_BUFFER3: 34856,
+  DRAW_BUFFER4: 34857,
+  DRAW_BUFFER5: 34858,
+  DRAW_BUFFER6: 34859,
+  DRAW_BUFFER7: 34860,
+  DRAW_BUFFER8: 34861,
+  DRAW_BUFFER9: 34862,
+  DRAW_BUFFER10: 34863,
+  DRAW_BUFFER11: 34864,
+  DRAW_BUFFER12: 34865,
+  DRAW_BUFFER13: 34866,
+  DRAW_BUFFER14: 34867,
+  DRAW_BUFFER15: 34868,
+  MAX_FRAGMENT_UNIFORM_COMPONENTS: 35657,
+  MAX_VERTEX_UNIFORM_COMPONENTS: 35658,
+  SAMPLER_3D: 35679,
+  SAMPLER_2D_SHADOW: 35682,
+  FRAGMENT_SHADER_DERIVATIVE_HINT: 35723,
+  PIXEL_PACK_BUFFER: 35051,
+  PIXEL_UNPACK_BUFFER: 35052,
+  PIXEL_PACK_BUFFER_BINDING: 35053,
+  PIXEL_UNPACK_BUFFER_BINDING: 35055,
+  FLOAT_MAT2x3: 35685,
+  FLOAT_MAT2x4: 35686,
+  FLOAT_MAT3x2: 35687,
+  FLOAT_MAT3x4: 35688,
+  FLOAT_MAT4x2: 35689,
+  FLOAT_MAT4x3: 35690,
+  SRGB: 35904,
+  SRGB8: 35905,
+  SRGB8_ALPHA8: 35907,
+  COMPARE_REF_TO_TEXTURE: 34894,
+  RGBA32F: 34836,
+  RGB32F: 34837,
+  RGBA16F: 34842,
+  RGB16F: 34843,
+  VERTEX_ATTRIB_ARRAY_INTEGER: 35069,
+  MAX_ARRAY_TEXTURE_LAYERS: 35071,
+  MIN_PROGRAM_TEXEL_OFFSET: 35076,
+  MAX_PROGRAM_TEXEL_OFFSET: 35077,
+  MAX_VARYING_COMPONENTS: 35659,
+  TEXTURE_2D_ARRAY: 35866,
+  TEXTURE_BINDING_2D_ARRAY: 35869,
+  R11F_G11F_B10F: 35898,
+  UNSIGNED_INT_10F_11F_11F_REV: 35899,
+  RGB9_E5: 35901,
+  UNSIGNED_INT_5_9_9_9_REV: 35902,
+  TRANSFORM_FEEDBACK_BUFFER_MODE: 35967,
+  MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: 35968,
+  TRANSFORM_FEEDBACK_VARYINGS: 35971,
+  TRANSFORM_FEEDBACK_BUFFER_START: 35972,
+  TRANSFORM_FEEDBACK_BUFFER_SIZE: 35973,
+  TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 35976,
+  RASTERIZER_DISCARD: 35977,
+  MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: 35978,
+  MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: 35979,
+  INTERLEAVED_ATTRIBS: 35980,
+  SEPARATE_ATTRIBS: 35981,
+  TRANSFORM_FEEDBACK_BUFFER: 35982,
+  TRANSFORM_FEEDBACK_BUFFER_BINDING: 35983,
+  RGBA32UI: 36208,
+  RGB32UI: 36209,
+  RGBA16UI: 36214,
+  RGB16UI: 36215,
+  RGBA8UI: 36220,
+  RGB8UI: 36221,
+  RGBA32I: 36226,
+  RGB32I: 36227,
+  RGBA16I: 36232,
+  RGB16I: 36233,
+  RGBA8I: 36238,
+  RGB8I: 36239,
+  RED_INTEGER: 36244,
+  RGB_INTEGER: 36248,
+  RGBA_INTEGER: 36249,
+  SAMPLER_2D_ARRAY: 36289,
+  SAMPLER_2D_ARRAY_SHADOW: 36292,
+  SAMPLER_CUBE_SHADOW: 36293,
+  UNSIGNED_INT_VEC2: 36294,
+  UNSIGNED_INT_VEC3: 36295,
+  UNSIGNED_INT_VEC4: 36296,
+  INT_SAMPLER_2D: 36298,
+  INT_SAMPLER_3D: 36299,
+  INT_SAMPLER_CUBE: 36300,
+  INT_SAMPLER_2D_ARRAY: 36303,
+  UNSIGNED_INT_SAMPLER_2D: 36306,
+  UNSIGNED_INT_SAMPLER_3D: 36307,
+  UNSIGNED_INT_SAMPLER_CUBE: 36308,
+  UNSIGNED_INT_SAMPLER_2D_ARRAY: 36311,
+  DEPTH_COMPONENT32F: 36012,
+  DEPTH32F_STENCIL8: 36013,
+  FLOAT_32_UNSIGNED_INT_24_8_REV: 36269,
+  FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: 33296,
+  FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: 33297,
+  FRAMEBUFFER_ATTACHMENT_RED_SIZE: 33298,
+  FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: 33299,
+  FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: 33300,
+  FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: 33301,
+  FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: 33302,
+  FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: 33303,
+  FRAMEBUFFER_DEFAULT: 33304,
+  UNSIGNED_INT_24_8: 34042,
+  DEPTH24_STENCIL8: 35056,
+  UNSIGNED_NORMALIZED: 35863,
+  DRAW_FRAMEBUFFER_BINDING: 36006,
+  // Same as FRAMEBUFFER_BINDING
+  READ_FRAMEBUFFER: 36008,
+  DRAW_FRAMEBUFFER: 36009,
+  READ_FRAMEBUFFER_BINDING: 36010,
+  RENDERBUFFER_SAMPLES: 36011,
+  FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: 36052,
+  MAX_COLOR_ATTACHMENTS: 36063,
+  COLOR_ATTACHMENT1: 36065,
+  COLOR_ATTACHMENT2: 36066,
+  COLOR_ATTACHMENT3: 36067,
+  COLOR_ATTACHMENT4: 36068,
+  COLOR_ATTACHMENT5: 36069,
+  COLOR_ATTACHMENT6: 36070,
+  COLOR_ATTACHMENT7: 36071,
+  COLOR_ATTACHMENT8: 36072,
+  COLOR_ATTACHMENT9: 36073,
+  COLOR_ATTACHMENT10: 36074,
+  COLOR_ATTACHMENT11: 36075,
+  COLOR_ATTACHMENT12: 36076,
+  COLOR_ATTACHMENT13: 36077,
+  COLOR_ATTACHMENT14: 36078,
+  COLOR_ATTACHMENT15: 36079,
+  FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: 36182,
+  MAX_SAMPLES: 36183,
+  HALF_FLOAT: 5131,
+  RG: 33319,
+  RG_INTEGER: 33320,
+  R8: 33321,
+  RG8: 33323,
+  R16F: 33325,
+  R32F: 33326,
+  RG16F: 33327,
+  RG32F: 33328,
+  R8I: 33329,
+  R8UI: 33330,
+  R16I: 33331,
+  R16UI: 33332,
+  R32I: 33333,
+  R32UI: 33334,
+  RG8I: 33335,
+  RG8UI: 33336,
+  RG16I: 33337,
+  RG16UI: 33338,
+  RG32I: 33339,
+  RG32UI: 33340,
+  VERTEX_ARRAY_BINDING: 34229,
+  R8_SNORM: 36756,
+  RG8_SNORM: 36757,
+  RGB8_SNORM: 36758,
+  RGBA8_SNORM: 36759,
+  SIGNED_NORMALIZED: 36764,
+  COPY_READ_BUFFER: 36662,
+  COPY_WRITE_BUFFER: 36663,
+  COPY_READ_BUFFER_BINDING: 36662,
+  // Same as COPY_READ_BUFFER
+  COPY_WRITE_BUFFER_BINDING: 36663,
+  // Same as COPY_WRITE_BUFFER
+  UNIFORM_BUFFER: 35345,
+  UNIFORM_BUFFER_BINDING: 35368,
+  UNIFORM_BUFFER_START: 35369,
+  UNIFORM_BUFFER_SIZE: 35370,
+  MAX_VERTEX_UNIFORM_BLOCKS: 35371,
+  MAX_FRAGMENT_UNIFORM_BLOCKS: 35373,
+  MAX_COMBINED_UNIFORM_BLOCKS: 35374,
+  MAX_UNIFORM_BUFFER_BINDINGS: 35375,
+  MAX_UNIFORM_BLOCK_SIZE: 35376,
+  MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: 35377,
+  MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: 35379,
+  UNIFORM_BUFFER_OFFSET_ALIGNMENT: 35380,
+  ACTIVE_UNIFORM_BLOCKS: 35382,
+  UNIFORM_TYPE: 35383,
+  UNIFORM_SIZE: 35384,
+  UNIFORM_BLOCK_INDEX: 35386,
+  UNIFORM_OFFSET: 35387,
+  UNIFORM_ARRAY_STRIDE: 35388,
+  UNIFORM_MATRIX_STRIDE: 35389,
+  UNIFORM_IS_ROW_MAJOR: 35390,
+  UNIFORM_BLOCK_BINDING: 35391,
+  UNIFORM_BLOCK_DATA_SIZE: 35392,
+  UNIFORM_BLOCK_ACTIVE_UNIFORMS: 35394,
+  UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: 35395,
+  UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: 35396,
+  UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: 35398,
+  INVALID_INDEX: 4294967295,
+  MAX_VERTEX_OUTPUT_COMPONENTS: 37154,
+  MAX_FRAGMENT_INPUT_COMPONENTS: 37157,
+  MAX_SERVER_WAIT_TIMEOUT: 37137,
+  OBJECT_TYPE: 37138,
+  SYNC_CONDITION: 37139,
+  SYNC_STATUS: 37140,
+  SYNC_FLAGS: 37141,
+  SYNC_FENCE: 37142,
+  SYNC_GPU_COMMANDS_COMPLETE: 37143,
+  UNSIGNALED: 37144,
+  SIGNALED: 37145,
+  ALREADY_SIGNALED: 37146,
+  TIMEOUT_EXPIRED: 37147,
+  CONDITION_SATISFIED: 37148,
+  WAIT_FAILED: 37149,
+  SYNC_FLUSH_COMMANDS_BIT: 1,
+  VERTEX_ATTRIB_ARRAY_DIVISOR: 35070,
+  ANY_SAMPLES_PASSED: 35887,
+  ANY_SAMPLES_PASSED_CONSERVATIVE: 36202,
+  SAMPLER_BINDING: 35097,
+  RGB10_A2UI: 36975,
+  INT_2_10_10_10_REV: 36255,
+  TRANSFORM_FEEDBACK: 36386,
+  TRANSFORM_FEEDBACK_PAUSED: 36387,
+  TRANSFORM_FEEDBACK_ACTIVE: 36388,
+  TRANSFORM_FEEDBACK_BINDING: 36389,
+  COMPRESSED_R11_EAC: 37488,
+  COMPRESSED_SIGNED_R11_EAC: 37489,
+  COMPRESSED_RG11_EAC: 37490,
+  COMPRESSED_SIGNED_RG11_EAC: 37491,
+  COMPRESSED_RGB8_ETC2: 37492,
+  COMPRESSED_SRGB8_ETC2: 37493,
+  COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37494,
+  COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37495,
+  COMPRESSED_RGBA8_ETC2_EAC: 37496,
+  COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37497,
+  TEXTURE_IMMUTABLE_FORMAT: 37167,
+  MAX_ELEMENT_INDEX: 36203,
+  TEXTURE_IMMUTABLE_LEVELS: 33503,
+  // Extensions
+  MAX_TEXTURE_MAX_ANISOTROPY_EXT: 34047
+};
+var WebGLConstants_default = Object.freeze(WebGLConstants);
+
+export {
+  WebGLConstants_default
+};

public/assets/cesium/Workers/chunk-3IFRSGEY.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  PolylinePipeline_default
+} from "./chunk-QN6TBED4.js";
+import {
+  EllipsoidTangentPlane_default
+} from "./chunk-YK3QIKY7.js";
+import {
+  Cartesian4_default,
+  Matrix4_default,
+  Quaternion_default,
+  Transforms_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  Cartesian2_default,
+  Cartesian3_default,
+  Cartographic_default,
+  Matrix3_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import {
+  defaultValue_default
+} from "./chunk-U5HSOKPQ.js";
+import {
+  DeveloperError_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/CornerType.js
+var CornerType = {
+  /**
+   * <img src="Images/CornerTypeRounded.png" style="vertical-align: middle;" width="186" height="189" />
+   *
+   * Corner has a smooth edge.
+   * @type {number}
+   * @constant
+   */
+  ROUNDED: 0,
+  /**
+   * <img src="Images/CornerTypeMitered.png" style="vertical-align: middle;" width="186" height="189" />
+   *
+   * Corner point is the intersection of adjacent edges.
+   * @type {number}
+   * @constant
+   */
+  MITERED: 1,
+  /**
+   * <img src="Images/CornerTypeBeveled.png" style="vertical-align: middle;" width="186" height="189" />
+   *
+   * Corner is clipped.
+   * @type {number}
+   * @constant
+   */
+  BEVELED: 2
+};
+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();
+var scratchCartesian2 = new Cartesian3_default();
+var scratchCartesian3 = new Cartesian3_default();
+var scratchCartesian4 = new Cartesian3_default();
+var scratchCartesian5 = new Cartesian3_default();
+var scratchCartesian6 = new Cartesian3_default();
+var scratchCartesian7 = new Cartesian3_default();
+var scratchCartesian8 = new Cartesian3_default();
+var scratchCartesian9 = new Cartesian3_default();
+var scratch1 = new Cartesian3_default();
+var scratch2 = new Cartesian3_default();
+var PolylineVolumeGeometryLibrary = {};
+var cartographic = new Cartographic_default();
+function scaleToSurface(positions, ellipsoid) {
+  const heights = new Array(positions.length);
+  for (let i = 0; i < positions.length; i++) {
+    const pos = positions[i];
+    cartographic = ellipsoid.cartesianToCartographic(pos, cartographic);
+    heights[i] = cartographic.height;
+    positions[i] = ellipsoid.scaleToGeodeticSurface(pos, pos);
+  }
+  return heights;
+}
+function subdivideHeights(points, h0, h1, granularity) {
+  const p0 = points[0];
+  const p1 = points[1];
+  const angleBetween = Cartesian3_default.angleBetween(p0, p1);
+  const numPoints = Math.ceil(angleBetween / granularity);
+  const heights = new Array(numPoints);
+  let i;
+  if (h0 === h1) {
+    for (i = 0; i < numPoints; i++) {
+      heights[i] = h0;
+    }
+    heights.push(h1);
+    return heights;
+  }
+  const dHeight = h1 - h0;
+  const heightPerVertex = dHeight / numPoints;
+  for (i = 1; i < numPoints; i++) {
+    const h = h0 + i * heightPerVertex;
+    heights[i] = h;
+  }
+  heights[0] = h0;
+  heights.push(h1);
+  return heights;
+}
+var nextScratch = new Cartesian3_default();
+var prevScratch = new Cartesian3_default();
+function computeRotationAngle(start, end, position, ellipsoid) {
+  const tangentPlane = new EllipsoidTangentPlane_default(position, ellipsoid);
+  const next = tangentPlane.projectPointOntoPlane(
+    Cartesian3_default.add(position, start, nextScratch),
+    nextScratch
+  );
+  const prev = tangentPlane.projectPointOntoPlane(
+    Cartesian3_default.add(position, end, prevScratch),
+    prevScratch
+  );
+  const angle = Cartesian2_default.angleBetween(next, prev);
+  return prev.x * next.y - prev.y * next.x >= 0 ? -angle : angle;
+}
+var negativeX = new Cartesian3_default(-1, 0, 0);
+var transform = new Matrix4_default();
+var translation = new Matrix4_default();
+var rotationZ = new Matrix3_default();
+var scaleMatrix = Matrix3_default.IDENTITY.clone();
+var westScratch = new Cartesian3_default();
+var finalPosScratch = new Cartesian4_default();
+var heightCartesian = new Cartesian3_default();
+function addPosition(center, left, shape, finalPositions, ellipsoid, height, xScalar, repeat) {
+  let west = westScratch;
+  let finalPosition = finalPosScratch;
+  transform = Transforms_default.eastNorthUpToFixedFrame(center, ellipsoid, transform);
+  west = Matrix4_default.multiplyByPointAsVector(transform, negativeX, west);
+  west = Cartesian3_default.normalize(west, west);
+  const angle = computeRotationAngle(west, left, center, ellipsoid);
+  rotationZ = Matrix3_default.fromRotationZ(angle, rotationZ);
+  heightCartesian.z = height;
+  transform = Matrix4_default.multiplyTransformation(
+    transform,
+    Matrix4_default.fromRotationTranslation(rotationZ, heightCartesian, translation),
+    transform
+  );
+  const scale = scaleMatrix;
+  scale[0] = xScalar;
+  for (let j = 0; j < repeat; j++) {
+    for (let i = 0; i < shape.length; i += 3) {
+      finalPosition = Cartesian3_default.fromArray(shape, i, finalPosition);
+      finalPosition = Matrix3_default.multiplyByVector(
+        scale,
+        finalPosition,
+        finalPosition
+      );
+      finalPosition = Matrix4_default.multiplyByPoint(
+        transform,
+        finalPosition,
+        finalPosition
+      );
+      finalPositions.push(finalPosition.x, finalPosition.y, finalPosition.z);
+    }
+  }
+  return finalPositions;
+}
+var centerScratch = new Cartesian3_default();
+function addPositions(centers, left, shape, finalPositions, ellipsoid, heights, xScalar) {
+  for (let i = 0; i < centers.length; i += 3) {
+    const center = Cartesian3_default.fromArray(centers, i, centerScratch);
+    finalPositions = addPosition(
+      center,
+      left,
+      shape,
+      finalPositions,
+      ellipsoid,
+      heights[i / 3],
+      xScalar,
+      1
+    );
+  }
+  return finalPositions;
+}
+function convertShapeTo3DDuplicate(shape2D, boundingRectangle) {
+  const length = shape2D.length;
+  const shape = new Array(length * 6);
+  let index = 0;
+  const xOffset = boundingRectangle.x + boundingRectangle.width / 2;
+  const yOffset = boundingRectangle.y + boundingRectangle.height / 2;
+  let point = shape2D[0];
+  shape[index++] = point.x - xOffset;
+  shape[index++] = 0;
+  shape[index++] = point.y - yOffset;
+  for (let i = 1; i < length; i++) {
+    point = shape2D[i];
+    const x = point.x - xOffset;
+    const z = point.y - yOffset;
+    shape[index++] = x;
+    shape[index++] = 0;
+    shape[index++] = z;
+    shape[index++] = x;
+    shape[index++] = 0;
+    shape[index++] = z;
+  }
+  point = shape2D[0];
+  shape[index++] = point.x - xOffset;
+  shape[index++] = 0;
+  shape[index++] = point.y - yOffset;
+  return shape;
+}
+function convertShapeTo3D(shape2D, boundingRectangle) {
+  const length = shape2D.length;
+  const shape = new Array(length * 3);
+  let index = 0;
+  const xOffset = boundingRectangle.x + boundingRectangle.width / 2;
+  const yOffset = boundingRectangle.y + boundingRectangle.height / 2;
+  for (let i = 0; i < length; i++) {
+    shape[index++] = shape2D[i].x - xOffset;
+    shape[index++] = 0;
+    shape[index++] = shape2D[i].y - yOffset;
+  }
+  return shape;
+}
+var quaterion = new Quaternion_default();
+var startPointScratch = new Cartesian3_default();
+var rotMatrix = new Matrix3_default();
+function computeRoundCorner(pivot, startPoint, endPoint, cornerType, leftIsOutside, ellipsoid, finalPositions, shape, height, duplicatePoints) {
+  const angle = Cartesian3_default.angleBetween(
+    Cartesian3_default.subtract(startPoint, pivot, scratch1),
+    Cartesian3_default.subtract(endPoint, pivot, scratch2)
+  );
+  const granularity = cornerType === CornerType_default.BEVELED ? 0 : Math.ceil(angle / Math_default.toRadians(5));
+  let m;
+  if (leftIsOutside) {
+    m = Matrix3_default.fromQuaternion(
+      Quaternion_default.fromAxisAngle(
+        Cartesian3_default.negate(pivot, scratch1),
+        angle / (granularity + 1),
+        quaterion
+      ),
+      rotMatrix
+    );
+  } else {
+    m = Matrix3_default.fromQuaternion(
+      Quaternion_default.fromAxisAngle(pivot, angle / (granularity + 1), quaterion),
+      rotMatrix
+    );
+  }
+  let left;
+  let surfacePoint;
+  startPoint = Cartesian3_default.clone(startPoint, startPointScratch);
+  if (granularity > 0) {
+    const repeat = duplicatePoints ? 2 : 1;
+    for (let i = 0; i < granularity; i++) {
+      startPoint = Matrix3_default.multiplyByVector(m, startPoint, startPoint);
+      left = Cartesian3_default.subtract(startPoint, pivot, scratch1);
+      left = Cartesian3_default.normalize(left, left);
+      if (!leftIsOutside) {
+        left = Cartesian3_default.negate(left, left);
+      }
+      surfacePoint = ellipsoid.scaleToGeodeticSurface(startPoint, scratch2);
+      finalPositions = addPosition(
+        surfacePoint,
+        left,
+        shape,
+        finalPositions,
+        ellipsoid,
+        height,
+        1,
+        repeat
+      );
+    }
+  } else {
+    left = Cartesian3_default.subtract(startPoint, pivot, scratch1);
+    left = Cartesian3_default.normalize(left, left);
+    if (!leftIsOutside) {
+      left = Cartesian3_default.negate(left, left);
+    }
+    surfacePoint = ellipsoid.scaleToGeodeticSurface(startPoint, scratch2);
+    finalPositions = addPosition(
+      surfacePoint,
+      left,
+      shape,
+      finalPositions,
+      ellipsoid,
+      height,
+      1,
+      1
+    );
+    endPoint = Cartesian3_default.clone(endPoint, startPointScratch);
+    left = Cartesian3_default.subtract(endPoint, pivot, scratch1);
+    left = Cartesian3_default.normalize(left, left);
+    if (!leftIsOutside) {
+      left = Cartesian3_default.negate(left, left);
+    }
+    surfacePoint = ellipsoid.scaleToGeodeticSurface(endPoint, scratch2);
+    finalPositions = addPosition(
+      surfacePoint,
+      left,
+      shape,
+      finalPositions,
+      ellipsoid,
+      height,
+      1,
+      1
+    );
+  }
+  return finalPositions;
+}
+PolylineVolumeGeometryLibrary.removeDuplicatesFromShape = function(shapePositions) {
+  const length = shapePositions.length;
+  const cleanedPositions = [];
+  for (let i0 = length - 1, i1 = 0; i1 < length; i0 = i1++) {
+    const v0 = shapePositions[i0];
+    const v1 = shapePositions[i1];
+    if (!Cartesian2_default.equals(v0, v1)) {
+      cleanedPositions.push(v1);
+    }
+  }
+  return cleanedPositions;
+};
+PolylineVolumeGeometryLibrary.angleIsGreaterThanPi = function(forward, backward, position, ellipsoid) {
+  const tangentPlane = new EllipsoidTangentPlane_default(position, ellipsoid);
+  const next = tangentPlane.projectPointOntoPlane(
+    Cartesian3_default.add(position, forward, nextScratch),
+    nextScratch
+  );
+  const prev = tangentPlane.projectPointOntoPlane(
+    Cartesian3_default.add(position, backward, prevScratch),
+    prevScratch
+  );
+  return prev.x * next.y - prev.y * next.x >= 0;
+};
+var scratchForwardProjection = new Cartesian3_default();
+var scratchBackwardProjection = new Cartesian3_default();
+PolylineVolumeGeometryLibrary.computePositions = function(positions, shape2D, boundingRectangle, geometry, duplicatePoints) {
+  const ellipsoid = geometry._ellipsoid;
+  const heights = scaleToSurface(positions, ellipsoid);
+  const granularity = geometry._granularity;
+  const cornerType = geometry._cornerType;
+  const shapeForSides = duplicatePoints ? convertShapeTo3DDuplicate(shape2D, boundingRectangle) : convertShapeTo3D(shape2D, boundingRectangle);
+  const shapeForEnds = duplicatePoints ? convertShapeTo3D(shape2D, boundingRectangle) : void 0;
+  const heightOffset = boundingRectangle.height / 2;
+  const width = boundingRectangle.width / 2;
+  let length = positions.length;
+  let finalPositions = [];
+  let ends = duplicatePoints ? [] : void 0;
+  let forward = scratchCartesian1;
+  let backward = scratchCartesian2;
+  let cornerDirection = scratchCartesian3;
+  let surfaceNormal = scratchCartesian4;
+  let pivot = scratchCartesian5;
+  let start = scratchCartesian6;
+  let end = scratchCartesian7;
+  let left = scratchCartesian8;
+  let previousPosition = scratchCartesian9;
+  let position = positions[0];
+  let nextPosition = positions[1];
+  surfaceNormal = ellipsoid.geodeticSurfaceNormal(position, surfaceNormal);
+  forward = Cartesian3_default.subtract(nextPosition, position, forward);
+  forward = Cartesian3_default.normalize(forward, forward);
+  left = Cartesian3_default.cross(surfaceNormal, forward, left);
+  left = Cartesian3_default.normalize(left, left);
+  let h0 = heights[0];
+  let h1 = heights[1];
+  if (duplicatePoints) {
+    ends = addPosition(
+      position,
+      left,
+      shapeForEnds,
+      ends,
+      ellipsoid,
+      h0 + heightOffset,
+      1,
+      1
+    );
+  }
+  previousPosition = Cartesian3_default.clone(position, previousPosition);
+  position = nextPosition;
+  backward = Cartesian3_default.negate(forward, backward);
+  let subdividedHeights;
+  let subdividedPositions;
+  for (let i = 1; i < length - 1; i++) {
+    const repeat = duplicatePoints ? 2 : 1;
+    nextPosition = positions[i + 1];
+    if (position.equals(nextPosition)) {
+      oneTimeWarning_default(
+        "Positions are too close and are considered equivalent with rounding error."
+      );
+      continue;
+    }
+    forward = Cartesian3_default.subtract(nextPosition, position, forward);
+    forward = Cartesian3_default.normalize(forward, forward);
+    cornerDirection = Cartesian3_default.add(forward, backward, cornerDirection);
+    cornerDirection = Cartesian3_default.normalize(cornerDirection, cornerDirection);
+    surfaceNormal = ellipsoid.geodeticSurfaceNormal(position, surfaceNormal);
+    const forwardProjection = Cartesian3_default.multiplyByScalar(
+      surfaceNormal,
+      Cartesian3_default.dot(forward, surfaceNormal),
+      scratchForwardProjection
+    );
+    Cartesian3_default.subtract(forward, forwardProjection, forwardProjection);
+    Cartesian3_default.normalize(forwardProjection, forwardProjection);
+    const backwardProjection = Cartesian3_default.multiplyByScalar(
+      surfaceNormal,
+      Cartesian3_default.dot(backward, surfaceNormal),
+      scratchBackwardProjection
+    );
+    Cartesian3_default.subtract(backward, backwardProjection, backwardProjection);
+    Cartesian3_default.normalize(backwardProjection, backwardProjection);
+    const doCorner = !Math_default.equalsEpsilon(
+      Math.abs(Cartesian3_default.dot(forwardProjection, backwardProjection)),
+      1,
+      Math_default.EPSILON7
+    );
+    if (doCorner) {
+      cornerDirection = Cartesian3_default.cross(
+        cornerDirection,
+        surfaceNormal,
+        cornerDirection
+      );
+      cornerDirection = Cartesian3_default.cross(
+        surfaceNormal,
+        cornerDirection,
+        cornerDirection
+      );
+      cornerDirection = Cartesian3_default.normalize(cornerDirection, cornerDirection);
+      const scalar = 1 / Math.max(
+        0.25,
+        Cartesian3_default.magnitude(
+          Cartesian3_default.cross(cornerDirection, backward, scratch1)
+        )
+      );
+      const leftIsOutside = PolylineVolumeGeometryLibrary.angleIsGreaterThanPi(
+        forward,
+        backward,
+        position,
+        ellipsoid
+      );
+      if (leftIsOutside) {
+        pivot = Cartesian3_default.add(
+          position,
+          Cartesian3_default.multiplyByScalar(
+            cornerDirection,
+            scalar * width,
+            cornerDirection
+          ),
+          pivot
+        );
+        start = Cartesian3_default.add(
+          pivot,
+          Cartesian3_default.multiplyByScalar(left, width, start),
+          start
+        );
+        scratch2Array[0] = Cartesian3_default.clone(previousPosition, scratch2Array[0]);
+        scratch2Array[1] = Cartesian3_default.clone(start, scratch2Array[1]);
+        subdividedHeights = subdivideHeights(
+          scratch2Array,
+          h0 + heightOffset,
+          h1 + heightOffset,
+          granularity
+        );
+        subdividedPositions = PolylinePipeline_default.generateArc({
+          positions: scratch2Array,
+          granularity,
+          ellipsoid
+        });
+        finalPositions = addPositions(
+          subdividedPositions,
+          left,
+          shapeForSides,
+          finalPositions,
+          ellipsoid,
+          subdividedHeights,
+          1
+        );
+        left = Cartesian3_default.cross(surfaceNormal, forward, left);
+        left = Cartesian3_default.normalize(left, left);
+        end = Cartesian3_default.add(
+          pivot,
+          Cartesian3_default.multiplyByScalar(left, width, end),
+          end
+        );
+        if (cornerType === CornerType_default.ROUNDED || cornerType === CornerType_default.BEVELED) {
+          computeRoundCorner(
+            pivot,
+            start,
+            end,
+            cornerType,
+            leftIsOutside,
+            ellipsoid,
+            finalPositions,
+            shapeForSides,
+            h1 + heightOffset,
+            duplicatePoints
+          );
+        } else {
+          cornerDirection = Cartesian3_default.negate(cornerDirection, cornerDirection);
+          finalPositions = addPosition(
+            position,
+            cornerDirection,
+            shapeForSides,
+            finalPositions,
+            ellipsoid,
+            h1 + heightOffset,
+            scalar,
+            repeat
+          );
+        }
+        previousPosition = Cartesian3_default.clone(end, previousPosition);
+      } else {
+        pivot = Cartesian3_default.add(
+          position,
+          Cartesian3_default.multiplyByScalar(
+            cornerDirection,
+            scalar * width,
+            cornerDirection
+          ),
+          pivot
+        );
+        start = Cartesian3_default.add(
+          pivot,
+          Cartesian3_default.multiplyByScalar(left, -width, start),
+          start
+        );
+        scratch2Array[0] = Cartesian3_default.clone(previousPosition, scratch2Array[0]);
+        scratch2Array[1] = Cartesian3_default.clone(start, scratch2Array[1]);
+        subdividedHeights = subdivideHeights(
+          scratch2Array,
+          h0 + heightOffset,
+          h1 + heightOffset,
+          granularity
+        );
+        subdividedPositions = PolylinePipeline_default.generateArc({
+          positions: scratch2Array,
+          granularity,
+          ellipsoid
+        });
+        finalPositions = addPositions(
+          subdividedPositions,
+          left,
+          shapeForSides,
+          finalPositions,
+          ellipsoid,
+          subdividedHeights,
+          1
+        );
+        left = Cartesian3_default.cross(surfaceNormal, forward, left);
+        left = Cartesian3_default.normalize(left, left);
+        end = Cartesian3_default.add(
+          pivot,
+          Cartesian3_default.multiplyByScalar(left, -width, end),
+          end
+        );
+        if (cornerType === CornerType_default.ROUNDED || cornerType === CornerType_default.BEVELED) {
+          computeRoundCorner(
+            pivot,
+            start,
+            end,
+            cornerType,
+            leftIsOutside,
+            ellipsoid,
+            finalPositions,
+            shapeForSides,
+            h1 + heightOffset,
+            duplicatePoints
+          );
+        } else {
+          finalPositions = addPosition(
+            position,
+            cornerDirection,
+            shapeForSides,
+            finalPositions,
+            ellipsoid,
+            h1 + heightOffset,
+            scalar,
+            repeat
+          );
+        }
+        previousPosition = Cartesian3_default.clone(end, previousPosition);
+      }
+      backward = Cartesian3_default.negate(forward, backward);
+    } else {
+      finalPositions = addPosition(
+        previousPosition,
+        left,
+        shapeForSides,
+        finalPositions,
+        ellipsoid,
+        h0 + heightOffset,
+        1,
+        1
+      );
+      previousPosition = position;
+    }
+    h0 = h1;
+    h1 = heights[i + 1];
+    position = nextPosition;
+  }
+  scratch2Array[0] = Cartesian3_default.clone(previousPosition, scratch2Array[0]);
+  scratch2Array[1] = Cartesian3_default.clone(position, scratch2Array[1]);
+  subdividedHeights = subdivideHeights(
+    scratch2Array,
+    h0 + heightOffset,
+    h1 + heightOffset,
+    granularity
+  );
+  subdividedPositions = PolylinePipeline_default.generateArc({
+    positions: scratch2Array,
+    granularity,
+    ellipsoid
+  });
+  finalPositions = addPositions(
+    subdividedPositions,
+    left,
+    shapeForSides,
+    finalPositions,
+    ellipsoid,
+    subdividedHeights,
+    1
+  );
+  if (duplicatePoints) {
+    ends = addPosition(
+      position,
+      left,
+      shapeForEnds,
+      ends,
+      ellipsoid,
+      h1 + heightOffset,
+      1,
+      1
+    );
+  }
+  length = finalPositions.length;
+  const posLength = duplicatePoints ? length + ends.length : length;
+  const combinedPositions = new Float64Array(posLength);
+  combinedPositions.set(finalPositions);
+  if (duplicatePoints) {
+    combinedPositions.set(ends, length);
+  }
+  return combinedPositions;
+};
+var PolylineVolumeGeometryLibrary_default = PolylineVolumeGeometryLibrary;
+
+export {
+  CornerType_default,
+  oneTimeWarning_default,
+  PolylineVolumeGeometryLibrary_default
+};

public/assets/cesium/Workers/chunk-44QAAS4P.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  GeographicProjection_default,
+  Intersect_default
+} from "./chunk-KHZNBFOH.js";
+import {
+  Rectangle_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  Cartesian2_default,
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  defaultValue_default
+} from "./chunk-U5HSOKPQ.js";
+import {
+  Check_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/BoundingRectangle.js
+function BoundingRectangle(x, y, width, height) {
+  this.x = defaultValue_default(x, 0);
+  this.y = defaultValue_default(y, 0);
+  this.width = defaultValue_default(width, 0);
+  this.height = defaultValue_default(height, 0);
+}
+BoundingRectangle.packedLength = 4;
+BoundingRectangle.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;
+  array[startingIndex++] = value.width;
+  array[startingIndex] = value.height;
+  return array;
+};
+BoundingRectangle.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  if (!defined_default(result)) {
+    result = new BoundingRectangle();
+  }
+  result.x = array[startingIndex++];
+  result.y = array[startingIndex++];
+  result.width = array[startingIndex++];
+  result.height = array[startingIndex];
+  return result;
+};
+BoundingRectangle.fromPoints = function(positions, result) {
+  if (!defined_default(result)) {
+    result = new BoundingRectangle();
+  }
+  if (!defined_default(positions) || positions.length === 0) {
+    result.x = 0;
+    result.y = 0;
+    result.width = 0;
+    result.height = 0;
+    return result;
+  }
+  const length = positions.length;
+  let minimumX = positions[0].x;
+  let minimumY = positions[0].y;
+  let maximumX = positions[0].x;
+  let maximumY = positions[0].y;
+  for (let i = 1; i < length; i++) {
+    const p = positions[i];
+    const x = p.x;
+    const y = p.y;
+    minimumX = Math.min(x, minimumX);
+    maximumX = Math.max(x, maximumX);
+    minimumY = Math.min(y, minimumY);
+    maximumY = Math.max(y, maximumY);
+  }
+  result.x = minimumX;
+  result.y = minimumY;
+  result.width = maximumX - minimumX;
+  result.height = maximumY - minimumY;
+  return result;
+};
+var defaultProjection = new GeographicProjection_default();
+var fromRectangleLowerLeft = new Cartographic_default();
+var fromRectangleUpperRight = new Cartographic_default();
+BoundingRectangle.fromRectangle = function(rectangle, projection, result) {
+  if (!defined_default(result)) {
+    result = new BoundingRectangle();
+  }
+  if (!defined_default(rectangle)) {
+    result.x = 0;
+    result.y = 0;
+    result.width = 0;
+    result.height = 0;
+    return result;
+  }
+  defaultProjection._ellipsoid = Ellipsoid_default.default;
+  projection = defaultValue_default(projection, defaultProjection);
+  const lowerLeft = projection.project(
+    Rectangle_default.southwest(rectangle, fromRectangleLowerLeft)
+  );
+  const upperRight = projection.project(
+    Rectangle_default.northeast(rectangle, fromRectangleUpperRight)
+  );
+  Cartesian2_default.subtract(upperRight, lowerLeft, upperRight);
+  result.x = lowerLeft.x;
+  result.y = lowerLeft.y;
+  result.width = upperRight.x;
+  result.height = upperRight.y;
+  return result;
+};
+BoundingRectangle.clone = function(rectangle, result) {
+  if (!defined_default(rectangle)) {
+    return void 0;
+  }
+  if (!defined_default(result)) {
+    return new BoundingRectangle(
+      rectangle.x,
+      rectangle.y,
+      rectangle.width,
+      rectangle.height
+    );
+  }
+  result.x = rectangle.x;
+  result.y = rectangle.y;
+  result.width = rectangle.width;
+  result.height = rectangle.height;
+  return result;
+};
+BoundingRectangle.union = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  if (!defined_default(result)) {
+    result = new BoundingRectangle();
+  }
+  const lowerLeftX = Math.min(left.x, right.x);
+  const lowerLeftY = Math.min(left.y, right.y);
+  const upperRightX = Math.max(left.x + left.width, right.x + right.width);
+  const upperRightY = Math.max(left.y + left.height, right.y + right.height);
+  result.x = lowerLeftX;
+  result.y = lowerLeftY;
+  result.width = upperRightX - lowerLeftX;
+  result.height = upperRightY - lowerLeftY;
+  return result;
+};
+BoundingRectangle.expand = function(rectangle, point, result) {
+  Check_default.typeOf.object("rectangle", rectangle);
+  Check_default.typeOf.object("point", point);
+  result = BoundingRectangle.clone(rectangle, result);
+  const width = point.x - result.x;
+  const height = point.y - result.y;
+  if (width > result.width) {
+    result.width = width;
+  } else if (width < 0) {
+    result.width -= width;
+    result.x = point.x;
+  }
+  if (height > result.height) {
+    result.height = height;
+  } else if (height < 0) {
+    result.height -= height;
+    result.y = point.y;
+  }
+  return result;
+};
+BoundingRectangle.intersect = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  const leftX = left.x;
+  const leftY = left.y;
+  const rightX = right.x;
+  const rightY = right.y;
+  if (!(leftX > rightX + right.width || leftX + left.width < rightX || leftY + left.height < rightY || leftY > rightY + right.height)) {
+    return Intersect_default.INTERSECTING;
+  }
+  return Intersect_default.OUTSIDE;
+};
+BoundingRectangle.equals = function(left, right) {
+  return left === right || defined_default(left) && defined_default(right) && left.x === right.x && left.y === right.y && left.width === right.width && left.height === right.height;
+};
+BoundingRectangle.prototype.clone = function(result) {
+  return BoundingRectangle.clone(this, result);
+};
+BoundingRectangle.prototype.intersect = function(right) {
+  return BoundingRectangle.intersect(this, right);
+};
+BoundingRectangle.prototype.equals = function(right) {
+  return BoundingRectangle.equals(this, right);
+};
+var BoundingRectangle_default = BoundingRectangle;
+
+export {
+  BoundingRectangle_default
+};

public/assets/cesium/Workers/chunk-56EDBCGT.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  AttributeCompression_default
+} from "./chunk-LJ2JQHJT.js";
+import {
+  BoundingSphere_default
+} from "./chunk-KHZNBFOH.js";
+import {
+  Matrix4_default,
+  Rectangle_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian2_default,
+  Cartesian3_default,
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import {
+  defaultValue_default
+} from "./chunk-U5HSOKPQ.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/EllipsoidalOccluder.js
+function EllipsoidalOccluder(ellipsoid, cameraPosition) {
+  Check_default.typeOf.object("ellipsoid", ellipsoid);
+  this._ellipsoid = ellipsoid;
+  this._cameraPosition = new Cartesian3_default();
+  this._cameraPositionInScaledSpace = new Cartesian3_default();
+  this._distanceToLimbInScaledSpaceSquared = 0;
+  if (defined_default(cameraPosition)) {
+    this.cameraPosition = cameraPosition;
+  }
+}
+Object.defineProperties(EllipsoidalOccluder.prototype, {
+  /**
+   * Gets the occluding ellipsoid.
+   * @memberof EllipsoidalOccluder.prototype
+   * @type {Ellipsoid}
+   */
+  ellipsoid: {
+    get: function() {
+      return this._ellipsoid;
+    }
+  },
+  /**
+   * Gets or sets the position of the camera.
+   * @memberof EllipsoidalOccluder.prototype
+   * @type {Cartesian3}
+   */
+  cameraPosition: {
+    get: function() {
+      return this._cameraPosition;
+    },
+    set: function(cameraPosition) {
+      const ellipsoid = this._ellipsoid;
+      const cv = ellipsoid.transformPositionToScaledSpace(
+        cameraPosition,
+        this._cameraPositionInScaledSpace
+      );
+      const vhMagnitudeSquared = Cartesian3_default.magnitudeSquared(cv) - 1;
+      Cartesian3_default.clone(cameraPosition, this._cameraPosition);
+      this._cameraPositionInScaledSpace = cv;
+      this._distanceToLimbInScaledSpaceSquared = vhMagnitudeSquared;
+    }
+  }
+});
+var scratchCartesian = new Cartesian3_default();
+EllipsoidalOccluder.prototype.isPointVisible = function(occludee) {
+  const ellipsoid = this._ellipsoid;
+  const occludeeScaledSpacePosition = ellipsoid.transformPositionToScaledSpace(
+    occludee,
+    scratchCartesian
+  );
+  return isScaledSpacePointVisible(
+    occludeeScaledSpacePosition,
+    this._cameraPositionInScaledSpace,
+    this._distanceToLimbInScaledSpaceSquared
+  );
+};
+EllipsoidalOccluder.prototype.isScaledSpacePointVisible = function(occludeeScaledSpacePosition) {
+  return isScaledSpacePointVisible(
+    occludeeScaledSpacePosition,
+    this._cameraPositionInScaledSpace,
+    this._distanceToLimbInScaledSpaceSquared
+  );
+};
+var scratchCameraPositionInScaledSpaceShrunk = new Cartesian3_default();
+EllipsoidalOccluder.prototype.isScaledSpacePointVisiblePossiblyUnderEllipsoid = function(occludeeScaledSpacePosition, minimumHeight) {
+  const ellipsoid = this._ellipsoid;
+  let vhMagnitudeSquared;
+  let cv;
+  if (defined_default(minimumHeight) && minimumHeight < 0 && ellipsoid.minimumRadius > -minimumHeight) {
+    cv = scratchCameraPositionInScaledSpaceShrunk;
+    cv.x = this._cameraPosition.x / (ellipsoid.radii.x + minimumHeight);
+    cv.y = this._cameraPosition.y / (ellipsoid.radii.y + minimumHeight);
+    cv.z = this._cameraPosition.z / (ellipsoid.radii.z + minimumHeight);
+    vhMagnitudeSquared = cv.x * cv.x + cv.y * cv.y + cv.z * cv.z - 1;
+  } else {
+    cv = this._cameraPositionInScaledSpace;
+    vhMagnitudeSquared = this._distanceToLimbInScaledSpaceSquared;
+  }
+  return isScaledSpacePointVisible(
+    occludeeScaledSpacePosition,
+    cv,
+    vhMagnitudeSquared
+  );
+};
+EllipsoidalOccluder.prototype.computeHorizonCullingPoint = function(directionToPoint, positions, result) {
+  return computeHorizonCullingPointFromPositions(
+    this._ellipsoid,
+    directionToPoint,
+    positions,
+    result
+  );
+};
+var scratchEllipsoidShrunk = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
+EllipsoidalOccluder.prototype.computeHorizonCullingPointPossiblyUnderEllipsoid = function(directionToPoint, positions, minimumHeight, result) {
+  const possiblyShrunkEllipsoid = getPossiblyShrunkEllipsoid(
+    this._ellipsoid,
+    minimumHeight,
+    scratchEllipsoidShrunk
+  );
+  return computeHorizonCullingPointFromPositions(
+    possiblyShrunkEllipsoid,
+    directionToPoint,
+    positions,
+    result
+  );
+};
+EllipsoidalOccluder.prototype.computeHorizonCullingPointFromVertices = function(directionToPoint, vertices, stride, center, result) {
+  return computeHorizonCullingPointFromVertices(
+    this._ellipsoid,
+    directionToPoint,
+    vertices,
+    stride,
+    center,
+    result
+  );
+};
+EllipsoidalOccluder.prototype.computeHorizonCullingPointFromVerticesPossiblyUnderEllipsoid = function(directionToPoint, vertices, stride, center, minimumHeight, result) {
+  const possiblyShrunkEllipsoid = getPossiblyShrunkEllipsoid(
+    this._ellipsoid,
+    minimumHeight,
+    scratchEllipsoidShrunk
+  );
+  return computeHorizonCullingPointFromVertices(
+    possiblyShrunkEllipsoid,
+    directionToPoint,
+    vertices,
+    stride,
+    center,
+    result
+  );
+};
+var subsampleScratch = [];
+EllipsoidalOccluder.prototype.computeHorizonCullingPointFromRectangle = function(rectangle, ellipsoid, result) {
+  Check_default.typeOf.object("rectangle", rectangle);
+  const positions = Rectangle_default.subsample(
+    rectangle,
+    ellipsoid,
+    0,
+    subsampleScratch
+  );
+  const bs = BoundingSphere_default.fromPoints(positions);
+  if (Cartesian3_default.magnitude(bs.center) < 0.1 * ellipsoid.minimumRadius) {
+    return void 0;
+  }
+  return this.computeHorizonCullingPoint(bs.center, positions, result);
+};
+var scratchEllipsoidShrunkRadii = new Cartesian3_default();
+function getPossiblyShrunkEllipsoid(ellipsoid, minimumHeight, result) {
+  if (defined_default(minimumHeight) && minimumHeight < 0 && ellipsoid.minimumRadius > -minimumHeight) {
+    const ellipsoidShrunkRadii = Cartesian3_default.fromElements(
+      ellipsoid.radii.x + minimumHeight,
+      ellipsoid.radii.y + minimumHeight,
+      ellipsoid.radii.z + minimumHeight,
+      scratchEllipsoidShrunkRadii
+    );
+    ellipsoid = Ellipsoid_default.fromCartesian3(ellipsoidShrunkRadii, result);
+  }
+  return ellipsoid;
+}
+function computeHorizonCullingPointFromPositions(ellipsoid, directionToPoint, positions, result) {
+  Check_default.typeOf.object("directionToPoint", directionToPoint);
+  Check_default.defined("positions", positions);
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  const scaledSpaceDirectionToPoint = computeScaledSpaceDirectionToPoint(
+    ellipsoid,
+    directionToPoint
+  );
+  let resultMagnitude = 0;
+  for (let i = 0, len = positions.length; i < len; ++i) {
+    const position = positions[i];
+    const candidateMagnitude = computeMagnitude(
+      ellipsoid,
+      position,
+      scaledSpaceDirectionToPoint
+    );
+    if (candidateMagnitude < 0) {
+      return void 0;
+    }
+    resultMagnitude = Math.max(resultMagnitude, candidateMagnitude);
+  }
+  return magnitudeToPoint(scaledSpaceDirectionToPoint, resultMagnitude, result);
+}
+var positionScratch = new Cartesian3_default();
+function computeHorizonCullingPointFromVertices(ellipsoid, directionToPoint, vertices, stride, center, result) {
+  Check_default.typeOf.object("directionToPoint", directionToPoint);
+  Check_default.defined("vertices", vertices);
+  Check_default.typeOf.number("stride", stride);
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  stride = defaultValue_default(stride, 3);
+  center = defaultValue_default(center, Cartesian3_default.ZERO);
+  const scaledSpaceDirectionToPoint = computeScaledSpaceDirectionToPoint(
+    ellipsoid,
+    directionToPoint
+  );
+  let resultMagnitude = 0;
+  for (let i = 0, len = vertices.length; i < len; i += stride) {
+    positionScratch.x = vertices[i] + center.x;
+    positionScratch.y = vertices[i + 1] + center.y;
+    positionScratch.z = vertices[i + 2] + center.z;
+    const candidateMagnitude = computeMagnitude(
+      ellipsoid,
+      positionScratch,
+      scaledSpaceDirectionToPoint
+    );
+    if (candidateMagnitude < 0) {
+      return void 0;
+    }
+    resultMagnitude = Math.max(resultMagnitude, candidateMagnitude);
+  }
+  return magnitudeToPoint(scaledSpaceDirectionToPoint, resultMagnitude, result);
+}
+function isScaledSpacePointVisible(occludeeScaledSpacePosition, cameraPositionInScaledSpace, distanceToLimbInScaledSpaceSquared) {
+  const cv = cameraPositionInScaledSpace;
+  const vhMagnitudeSquared = distanceToLimbInScaledSpaceSquared;
+  const vt = Cartesian3_default.subtract(
+    occludeeScaledSpacePosition,
+    cv,
+    scratchCartesian
+  );
+  const vtDotVc = -Cartesian3_default.dot(vt, cv);
+  const isOccluded = vhMagnitudeSquared < 0 ? vtDotVc > 0 : vtDotVc > vhMagnitudeSquared && vtDotVc * vtDotVc / Cartesian3_default.magnitudeSquared(vt) > vhMagnitudeSquared;
+  return !isOccluded;
+}
+var scaledSpaceScratch = new Cartesian3_default();
+var directionScratch = new Cartesian3_default();
+function computeMagnitude(ellipsoid, position, scaledSpaceDirectionToPoint) {
+  const scaledSpacePosition = ellipsoid.transformPositionToScaledSpace(
+    position,
+    scaledSpaceScratch
+  );
+  let magnitudeSquared = Cartesian3_default.magnitudeSquared(scaledSpacePosition);
+  let magnitude = Math.sqrt(magnitudeSquared);
+  const direction = Cartesian3_default.divideByScalar(
+    scaledSpacePosition,
+    magnitude,
+    directionScratch
+  );
+  magnitudeSquared = Math.max(1, magnitudeSquared);
+  magnitude = Math.max(1, magnitude);
+  const cosAlpha = Cartesian3_default.dot(direction, scaledSpaceDirectionToPoint);
+  const sinAlpha = Cartesian3_default.magnitude(
+    Cartesian3_default.cross(direction, scaledSpaceDirectionToPoint, direction)
+  );
+  const cosBeta = 1 / magnitude;
+  const sinBeta = Math.sqrt(magnitudeSquared - 1) * cosBeta;
+  return 1 / (cosAlpha * cosBeta - sinAlpha * sinBeta);
+}
+function magnitudeToPoint(scaledSpaceDirectionToPoint, resultMagnitude, result) {
+  if (resultMagnitude <= 0 || resultMagnitude === 1 / 0 || resultMagnitude !== resultMagnitude) {
+    return void 0;
+  }
+  return Cartesian3_default.multiplyByScalar(
+    scaledSpaceDirectionToPoint,
+    resultMagnitude,
+    result
+  );
+}
+var directionToPointScratch = new Cartesian3_default();
+function computeScaledSpaceDirectionToPoint(ellipsoid, directionToPoint) {
+  if (Cartesian3_default.equals(directionToPoint, Cartesian3_default.ZERO)) {
+    return directionToPoint;
+  }
+  ellipsoid.transformPositionToScaledSpace(
+    directionToPoint,
+    directionToPointScratch
+  );
+  return Cartesian3_default.normalize(directionToPointScratch, directionToPointScratch);
+}
+var EllipsoidalOccluder_default = EllipsoidalOccluder;
+
+// packages/engine/Source/Core/VerticalExaggeration.js
+var VerticalExaggeration = {};
+VerticalExaggeration.getHeight = function(height, scale, relativeHeight) {
+  if (!Number.isFinite(scale)) {
+    throw new DeveloperError_default("scale must be a finite number.");
+  }
+  if (!Number.isFinite(relativeHeight)) {
+    throw new DeveloperError_default("relativeHeight must be a finite number.");
+  }
+  return (height - relativeHeight) * scale + relativeHeight;
+};
+var scratchCartographic = new Cartographic_default();
+VerticalExaggeration.getPosition = function(position, ellipsoid, verticalExaggeration, verticalExaggerationRelativeHeight, result) {
+  const cartographic = ellipsoid.cartesianToCartographic(
+    position,
+    scratchCartographic
+  );
+  if (!defined_default(cartographic)) {
+    return Cartesian3_default.clone(position, result);
+  }
+  const newHeight = VerticalExaggeration.getHeight(
+    cartographic.height,
+    verticalExaggeration,
+    verticalExaggerationRelativeHeight
+  );
+  return Cartesian3_default.fromRadians(
+    cartographic.longitude,
+    cartographic.latitude,
+    newHeight,
+    ellipsoid,
+    result
+  );
+};
+var VerticalExaggeration_default = VerticalExaggeration;
+
+// packages/engine/Source/Core/TerrainQuantization.js
+var TerrainQuantization = {
+  /**
+   * The vertices are not compressed.
+   *
+   * @type {number}
+   * @constant
+   */
+  NONE: 0,
+  /**
+   * The vertices are compressed to 12 bits.
+   *
+   * @type {number}
+   * @constant
+   */
+  BITS12: 1
+};
+var TerrainQuantization_default = Object.freeze(TerrainQuantization);
+
+// packages/engine/Source/Core/TerrainEncoding.js
+var cartesian3Scratch = new Cartesian3_default();
+var cartesian3DimScratch = new Cartesian3_default();
+var cartesian2Scratch = new Cartesian2_default();
+var matrix4Scratch = new Matrix4_default();
+var matrix4Scratch2 = new Matrix4_default();
+var SHIFT_LEFT_12 = Math.pow(2, 12);
+function TerrainEncoding(center, axisAlignedBoundingBox, minimumHeight, maximumHeight, fromENU, hasVertexNormals, hasWebMercatorT, hasGeodeticSurfaceNormals, exaggeration, exaggerationRelativeHeight) {
+  let quantization = TerrainQuantization_default.NONE;
+  let toENU;
+  let matrix;
+  if (defined_default(axisAlignedBoundingBox) && defined_default(minimumHeight) && defined_default(maximumHeight) && defined_default(fromENU)) {
+    const minimum = axisAlignedBoundingBox.minimum;
+    const maximum = axisAlignedBoundingBox.maximum;
+    const dimensions = Cartesian3_default.subtract(
+      maximum,
+      minimum,
+      cartesian3DimScratch
+    );
+    const hDim = maximumHeight - minimumHeight;
+    const maxDim = Math.max(Cartesian3_default.maximumComponent(dimensions), hDim);
+    if (maxDim < SHIFT_LEFT_12 - 1) {
+      quantization = TerrainQuantization_default.BITS12;
+    } else {
+      quantization = TerrainQuantization_default.NONE;
+    }
+    toENU = Matrix4_default.inverseTransformation(fromENU, new Matrix4_default());
+    const translation = Cartesian3_default.negate(minimum, cartesian3Scratch);
+    Matrix4_default.multiply(
+      Matrix4_default.fromTranslation(translation, matrix4Scratch),
+      toENU,
+      toENU
+    );
+    const scale = cartesian3Scratch;
+    scale.x = 1 / dimensions.x;
+    scale.y = 1 / dimensions.y;
+    scale.z = 1 / dimensions.z;
+    Matrix4_default.multiply(Matrix4_default.fromScale(scale, matrix4Scratch), toENU, toENU);
+    matrix = Matrix4_default.clone(fromENU);
+    Matrix4_default.setTranslation(matrix, Cartesian3_default.ZERO, matrix);
+    fromENU = Matrix4_default.clone(fromENU, new Matrix4_default());
+    const translationMatrix = Matrix4_default.fromTranslation(minimum, matrix4Scratch);
+    const scaleMatrix = Matrix4_default.fromScale(dimensions, matrix4Scratch2);
+    const st = Matrix4_default.multiply(translationMatrix, scaleMatrix, matrix4Scratch);
+    Matrix4_default.multiply(fromENU, st, fromENU);
+    Matrix4_default.multiply(matrix, st, matrix);
+  }
+  this.quantization = quantization;
+  this.minimumHeight = minimumHeight;
+  this.maximumHeight = maximumHeight;
+  this.center = Cartesian3_default.clone(center);
+  this.toScaledENU = toENU;
+  this.fromScaledENU = fromENU;
+  this.matrix = matrix;
+  this.hasVertexNormals = hasVertexNormals;
+  this.hasWebMercatorT = defaultValue_default(hasWebMercatorT, false);
+  this.hasGeodeticSurfaceNormals = defaultValue_default(
+    hasGeodeticSurfaceNormals,
+    false
+  );
+  this.exaggeration = defaultValue_default(exaggeration, 1);
+  this.exaggerationRelativeHeight = defaultValue_default(
+    exaggerationRelativeHeight,
+    0
+  );
+  this.stride = 0;
+  this._offsetGeodeticSurfaceNormal = 0;
+  this._offsetVertexNormal = 0;
+  this._calculateStrideAndOffsets();
+}
+TerrainEncoding.prototype.encode = function(vertexBuffer, bufferIndex, position, uv, height, normalToPack, webMercatorT, geodeticSurfaceNormal) {
+  const u = uv.x;
+  const v = uv.y;
+  if (this.quantization === TerrainQuantization_default.BITS12) {
+    position = Matrix4_default.multiplyByPoint(
+      this.toScaledENU,
+      position,
+      cartesian3Scratch
+    );
+    position.x = Math_default.clamp(position.x, 0, 1);
+    position.y = Math_default.clamp(position.y, 0, 1);
+    position.z = Math_default.clamp(position.z, 0, 1);
+    const hDim = this.maximumHeight - this.minimumHeight;
+    const h = Math_default.clamp((height - this.minimumHeight) / hDim, 0, 1);
+    Cartesian2_default.fromElements(position.x, position.y, cartesian2Scratch);
+    const compressed0 = AttributeCompression_default.compressTextureCoordinates(
+      cartesian2Scratch
+    );
+    Cartesian2_default.fromElements(position.z, h, cartesian2Scratch);
+    const compressed1 = AttributeCompression_default.compressTextureCoordinates(
+      cartesian2Scratch
+    );
+    Cartesian2_default.fromElements(u, v, cartesian2Scratch);
+    const compressed2 = AttributeCompression_default.compressTextureCoordinates(
+      cartesian2Scratch
+    );
+    vertexBuffer[bufferIndex++] = compressed0;
+    vertexBuffer[bufferIndex++] = compressed1;
+    vertexBuffer[bufferIndex++] = compressed2;
+    if (this.hasWebMercatorT) {
+      Cartesian2_default.fromElements(webMercatorT, 0, cartesian2Scratch);
+      const compressed3 = AttributeCompression_default.compressTextureCoordinates(
+        cartesian2Scratch
+      );
+      vertexBuffer[bufferIndex++] = compressed3;
+    }
+  } else {
+    Cartesian3_default.subtract(position, this.center, cartesian3Scratch);
+    vertexBuffer[bufferIndex++] = cartesian3Scratch.x;
+    vertexBuffer[bufferIndex++] = cartesian3Scratch.y;
+    vertexBuffer[bufferIndex++] = cartesian3Scratch.z;
+    vertexBuffer[bufferIndex++] = height;
+    vertexBuffer[bufferIndex++] = u;
+    vertexBuffer[bufferIndex++] = v;
+    if (this.hasWebMercatorT) {
+      vertexBuffer[bufferIndex++] = webMercatorT;
+    }
+  }
+  if (this.hasVertexNormals) {
+    vertexBuffer[bufferIndex++] = AttributeCompression_default.octPackFloat(
+      normalToPack
+    );
+  }
+  if (this.hasGeodeticSurfaceNormals) {
+    vertexBuffer[bufferIndex++] = geodeticSurfaceNormal.x;
+    vertexBuffer[bufferIndex++] = geodeticSurfaceNormal.y;
+    vertexBuffer[bufferIndex++] = geodeticSurfaceNormal.z;
+  }
+  return bufferIndex;
+};
+var scratchPosition = new Cartesian3_default();
+var scratchGeodeticSurfaceNormal = new Cartesian3_default();
+TerrainEncoding.prototype.addGeodeticSurfaceNormals = function(oldBuffer, newBuffer, ellipsoid) {
+  if (this.hasGeodeticSurfaceNormals) {
+    return;
+  }
+  const oldStride = this.stride;
+  const vertexCount = oldBuffer.length / oldStride;
+  this.hasGeodeticSurfaceNormals = true;
+  this._calculateStrideAndOffsets();
+  const newStride = this.stride;
+  for (let index = 0; index < vertexCount; index++) {
+    for (let offset = 0; offset < oldStride; offset++) {
+      const oldIndex = index * oldStride + offset;
+      const newIndex = index * newStride + offset;
+      newBuffer[newIndex] = oldBuffer[oldIndex];
+    }
+    const position = this.decodePosition(newBuffer, index, scratchPosition);
+    const geodeticSurfaceNormal = ellipsoid.geodeticSurfaceNormal(
+      position,
+      scratchGeodeticSurfaceNormal
+    );
+    const bufferIndex = index * newStride + this._offsetGeodeticSurfaceNormal;
+    newBuffer[bufferIndex] = geodeticSurfaceNormal.x;
+    newBuffer[bufferIndex + 1] = geodeticSurfaceNormal.y;
+    newBuffer[bufferIndex + 2] = geodeticSurfaceNormal.z;
+  }
+};
+TerrainEncoding.prototype.removeGeodeticSurfaceNormals = function(oldBuffer, newBuffer) {
+  if (!this.hasGeodeticSurfaceNormals) {
+    return;
+  }
+  const oldStride = this.stride;
+  const vertexCount = oldBuffer.length / oldStride;
+  this.hasGeodeticSurfaceNormals = false;
+  this._calculateStrideAndOffsets();
+  const newStride = this.stride;
+  for (let index = 0; index < vertexCount; index++) {
+    for (let offset = 0; offset < newStride; offset++) {
+      const oldIndex = index * oldStride + offset;
+      const newIndex = index * newStride + offset;
+      newBuffer[newIndex] = oldBuffer[oldIndex];
+    }
+  }
+};
+TerrainEncoding.prototype.decodePosition = function(buffer, index, result) {
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  index *= this.stride;
+  if (this.quantization === TerrainQuantization_default.BITS12) {
+    const xy = AttributeCompression_default.decompressTextureCoordinates(
+      buffer[index],
+      cartesian2Scratch
+    );
+    result.x = xy.x;
+    result.y = xy.y;
+    const zh = AttributeCompression_default.decompressTextureCoordinates(
+      buffer[index + 1],
+      cartesian2Scratch
+    );
+    result.z = zh.x;
+    return Matrix4_default.multiplyByPoint(this.fromScaledENU, result, result);
+  }
+  result.x = buffer[index];
+  result.y = buffer[index + 1];
+  result.z = buffer[index + 2];
+  return Cartesian3_default.add(result, this.center, result);
+};
+TerrainEncoding.prototype.getExaggeratedPosition = function(buffer, index, result) {
+  result = this.decodePosition(buffer, index, result);
+  const exaggeration = this.exaggeration;
+  const exaggerationRelativeHeight = this.exaggerationRelativeHeight;
+  const hasExaggeration = exaggeration !== 1;
+  if (hasExaggeration && this.hasGeodeticSurfaceNormals) {
+    const geodeticSurfaceNormal = this.decodeGeodeticSurfaceNormal(
+      buffer,
+      index,
+      scratchGeodeticSurfaceNormal
+    );
+    const rawHeight = this.decodeHeight(buffer, index);
+    const heightDifference = VerticalExaggeration_default.getHeight(
+      rawHeight,
+      exaggeration,
+      exaggerationRelativeHeight
+    ) - rawHeight;
+    result.x += geodeticSurfaceNormal.x * heightDifference;
+    result.y += geodeticSurfaceNormal.y * heightDifference;
+    result.z += geodeticSurfaceNormal.z * heightDifference;
+  }
+  return result;
+};
+TerrainEncoding.prototype.decodeTextureCoordinates = function(buffer, index, result) {
+  if (!defined_default(result)) {
+    result = new Cartesian2_default();
+  }
+  index *= this.stride;
+  if (this.quantization === TerrainQuantization_default.BITS12) {
+    return AttributeCompression_default.decompressTextureCoordinates(
+      buffer[index + 2],
+      result
+    );
+  }
+  return Cartesian2_default.fromElements(buffer[index + 4], buffer[index + 5], result);
+};
+TerrainEncoding.prototype.decodeHeight = function(buffer, index) {
+  index *= this.stride;
+  if (this.quantization === TerrainQuantization_default.BITS12) {
+    const zh = AttributeCompression_default.decompressTextureCoordinates(
+      buffer[index + 1],
+      cartesian2Scratch
+    );
+    return zh.y * (this.maximumHeight - this.minimumHeight) + this.minimumHeight;
+  }
+  return buffer[index + 3];
+};
+TerrainEncoding.prototype.decodeWebMercatorT = function(buffer, index) {
+  index *= this.stride;
+  if (this.quantization === TerrainQuantization_default.BITS12) {
+    return AttributeCompression_default.decompressTextureCoordinates(
+      buffer[index + 3],
+      cartesian2Scratch
+    ).x;
+  }
+  return buffer[index + 6];
+};
+TerrainEncoding.prototype.getOctEncodedNormal = function(buffer, index, result) {
+  index = index * this.stride + this._offsetVertexNormal;
+  const temp = buffer[index] / 256;
+  const x = Math.floor(temp);
+  const y = (temp - x) * 256;
+  return Cartesian2_default.fromElements(x, y, result);
+};
+TerrainEncoding.prototype.decodeGeodeticSurfaceNormal = function(buffer, index, result) {
+  index = index * this.stride + this._offsetGeodeticSurfaceNormal;
+  result.x = buffer[index];
+  result.y = buffer[index + 1];
+  result.z = buffer[index + 2];
+  return result;
+};
+TerrainEncoding.prototype._calculateStrideAndOffsets = function() {
+  let vertexStride = 0;
+  switch (this.quantization) {
+    case TerrainQuantization_default.BITS12:
+      vertexStride += 3;
+      break;
+    default:
+      vertexStride += 6;
+  }
+  if (this.hasWebMercatorT) {
+    vertexStride += 1;
+  }
+  if (this.hasVertexNormals) {
+    this._offsetVertexNormal = vertexStride;
+    vertexStride += 1;
+  }
+  if (this.hasGeodeticSurfaceNormals) {
+    this._offsetGeodeticSurfaceNormal = vertexStride;
+    vertexStride += 3;
+  }
+  this.stride = vertexStride;
+};
+var attributesIndicesNone = {
+  position3DAndHeight: 0,
+  textureCoordAndEncodedNormals: 1,
+  geodeticSurfaceNormal: 2
+};
+var attributesIndicesBits12 = {
+  compressed0: 0,
+  compressed1: 1,
+  geodeticSurfaceNormal: 2
+};
+TerrainEncoding.prototype.getAttributes = function(buffer) {
+  const datatype = ComponentDatatype_default.FLOAT;
+  const sizeInBytes = ComponentDatatype_default.getSizeInBytes(datatype);
+  const strideInBytes = this.stride * sizeInBytes;
+  let offsetInBytes = 0;
+  const attributes = [];
+  function addAttribute(index, componentsPerAttribute) {
+    attributes.push({
+      index,
+      vertexBuffer: buffer,
+      componentDatatype: datatype,
+      componentsPerAttribute,
+      offsetInBytes,
+      strideInBytes
+    });
+    offsetInBytes += componentsPerAttribute * sizeInBytes;
+  }
+  if (this.quantization === TerrainQuantization_default.NONE) {
+    addAttribute(attributesIndicesNone.position3DAndHeight, 4);
+    let componentsTexCoordAndNormals = 2;
+    componentsTexCoordAndNormals += this.hasWebMercatorT ? 1 : 0;
+    componentsTexCoordAndNormals += this.hasVertexNormals ? 1 : 0;
+    addAttribute(
+      attributesIndicesNone.textureCoordAndEncodedNormals,
+      componentsTexCoordAndNormals
+    );
+    if (this.hasGeodeticSurfaceNormals) {
+      addAttribute(attributesIndicesNone.geodeticSurfaceNormal, 3);
+    }
+  } else {
+    const usingAttribute0Component4 = this.hasWebMercatorT || this.hasVertexNormals;
+    const usingAttribute1Component1 = this.hasWebMercatorT && this.hasVertexNormals;
+    addAttribute(
+      attributesIndicesBits12.compressed0,
+      usingAttribute0Component4 ? 4 : 3
+    );
+    if (usingAttribute1Component1) {
+      addAttribute(attributesIndicesBits12.compressed1, 1);
+    }
+    if (this.hasGeodeticSurfaceNormals) {
+      addAttribute(attributesIndicesBits12.geodeticSurfaceNormal, 3);
+    }
+  }
+  return attributes;
+};
+TerrainEncoding.prototype.getAttributeLocations = function() {
+  if (this.quantization === TerrainQuantization_default.NONE) {
+    return attributesIndicesNone;
+  }
+  return attributesIndicesBits12;
+};
+TerrainEncoding.clone = function(encoding, result) {
+  if (!defined_default(encoding)) {
+    return void 0;
+  }
+  if (!defined_default(result)) {
+    result = new TerrainEncoding();
+  }
+  result.quantization = encoding.quantization;
+  result.minimumHeight = encoding.minimumHeight;
+  result.maximumHeight = encoding.maximumHeight;
+  result.center = Cartesian3_default.clone(encoding.center);
+  result.toScaledENU = Matrix4_default.clone(encoding.toScaledENU);
+  result.fromScaledENU = Matrix4_default.clone(encoding.fromScaledENU);
+  result.matrix = Matrix4_default.clone(encoding.matrix);
+  result.hasVertexNormals = encoding.hasVertexNormals;
+  result.hasWebMercatorT = encoding.hasWebMercatorT;
+  result.hasGeodeticSurfaceNormals = encoding.hasGeodeticSurfaceNormals;
+  result.exaggeration = encoding.exaggeration;
+  result.exaggerationRelativeHeight = encoding.exaggerationRelativeHeight;
+  result._calculateStrideAndOffsets();
+  return result;
+};
+var TerrainEncoding_default = TerrainEncoding;
+
+export {
+  EllipsoidalOccluder_default,
+  TerrainEncoding_default
+};

public/assets/cesium/Workers/chunk-57H6I3SV.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import {
+  defaultValue_default
+} from "./chunk-U5HSOKPQ.js";
+import {
+  Check_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/arrayRemoveDuplicates.js
+var removeDuplicatesEpsilon = Math_default.EPSILON10;
+function arrayRemoveDuplicates(values, equalsEpsilon, wrapAround, removedIndices) {
+  Check_default.defined("equalsEpsilon", equalsEpsilon);
+  if (!defined_default(values)) {
+    return void 0;
+  }
+  wrapAround = defaultValue_default(wrapAround, false);
+  const storeRemovedIndices = defined_default(removedIndices);
+  const length = values.length;
+  if (length < 2) {
+    return values;
+  }
+  let i;
+  let v0 = values[0];
+  let v1;
+  let cleanedValues;
+  let lastCleanIndex = 0;
+  let removedIndexLCI = -1;
+  for (i = 1; i < length; ++i) {
+    v1 = values[i];
+    if (equalsEpsilon(v0, v1, removeDuplicatesEpsilon)) {
+      if (!defined_default(cleanedValues)) {
+        cleanedValues = values.slice(0, i);
+        lastCleanIndex = i - 1;
+        removedIndexLCI = 0;
+      }
+      if (storeRemovedIndices) {
+        removedIndices.push(i);
+      }
+    } else {
+      if (defined_default(cleanedValues)) {
+        cleanedValues.push(v1);
+        lastCleanIndex = i;
+        if (storeRemovedIndices) {
+          removedIndexLCI = removedIndices.length;
+        }
+      }
+      v0 = v1;
+    }
+  }
+  if (wrapAround && equalsEpsilon(values[0], values[length - 1], removeDuplicatesEpsilon)) {
+    if (storeRemovedIndices) {
+      if (defined_default(cleanedValues)) {
+        removedIndices.splice(removedIndexLCI, 0, lastCleanIndex);
+      } else {
+        removedIndices.push(length - 1);
+      }
+    }
+    if (defined_default(cleanedValues)) {
+      cleanedValues.length -= 1;
+    } else {
+      cleanedValues = values.slice(0, -1);
+    }
+  }
+  return defined_default(cleanedValues) ? cleanedValues : values;
+}
+var arrayRemoveDuplicates_default = arrayRemoveDuplicates;
+
+export {
+  arrayRemoveDuplicates_default
+};

public/assets/cesium/Workers/chunk-7YIOHQWH.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  VertexFormat_default
+} from "./chunk-JBSKHTNX.js";
+import {
+  Plane_default
+} from "./chunk-EDLRS3AW.js";
+import {
+  GeometryAttributes_default
+} from "./chunk-X7IQYYHF.js";
+import {
+  GeometryAttribute_default,
+  Geometry_default,
+  PrimitiveType_default
+} from "./chunk-JXVLNVXC.js";
+import {
+  BoundingSphere_default,
+  Intersect_default
+} from "./chunk-KHZNBFOH.js";
+import {
+  Cartesian4_default,
+  Matrix4_default,
+  Quaternion_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian3_default,
+  Matrix3_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import {
+  defaultValue_default
+} from "./chunk-U5HSOKPQ.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/CullingVolume.js
+function CullingVolume(planes) {
+  this.planes = defaultValue_default(planes, []);
+}
+var faces = [new Cartesian3_default(), new Cartesian3_default(), new Cartesian3_default()];
+Cartesian3_default.clone(Cartesian3_default.UNIT_X, faces[0]);
+Cartesian3_default.clone(Cartesian3_default.UNIT_Y, faces[1]);
+Cartesian3_default.clone(Cartesian3_default.UNIT_Z, faces[2]);
+var scratchPlaneCenter = new Cartesian3_default();
+var scratchPlaneNormal = new Cartesian3_default();
+var scratchPlane = new Plane_default(new Cartesian3_default(1, 0, 0), 0);
+CullingVolume.fromBoundingSphere = function(boundingSphere, result) {
+  if (!defined_default(boundingSphere)) {
+    throw new DeveloperError_default("boundingSphere is required.");
+  }
+  if (!defined_default(result)) {
+    result = new CullingVolume();
+  }
+  const length = faces.length;
+  const planes = result.planes;
+  planes.length = 2 * length;
+  const center = boundingSphere.center;
+  const radius = boundingSphere.radius;
+  let planeIndex = 0;
+  for (let i = 0; i < length; ++i) {
+    const faceNormal = faces[i];
+    let plane0 = planes[planeIndex];
+    let plane1 = planes[planeIndex + 1];
+    if (!defined_default(plane0)) {
+      plane0 = planes[planeIndex] = new Cartesian4_default();
+    }
+    if (!defined_default(plane1)) {
+      plane1 = planes[planeIndex + 1] = new Cartesian4_default();
+    }
+    Cartesian3_default.multiplyByScalar(faceNormal, -radius, scratchPlaneCenter);
+    Cartesian3_default.add(center, scratchPlaneCenter, scratchPlaneCenter);
+    plane0.x = faceNormal.x;
+    plane0.y = faceNormal.y;
+    plane0.z = faceNormal.z;
+    plane0.w = -Cartesian3_default.dot(faceNormal, scratchPlaneCenter);
+    Cartesian3_default.multiplyByScalar(faceNormal, radius, scratchPlaneCenter);
+    Cartesian3_default.add(center, scratchPlaneCenter, scratchPlaneCenter);
+    plane1.x = -faceNormal.x;
+    plane1.y = -faceNormal.y;
+    plane1.z = -faceNormal.z;
+    plane1.w = -Cartesian3_default.dot(
+      Cartesian3_default.negate(faceNormal, scratchPlaneNormal),
+      scratchPlaneCenter
+    );
+    planeIndex += 2;
+  }
+  return result;
+};
+CullingVolume.prototype.computeVisibility = function(boundingVolume) {
+  if (!defined_default(boundingVolume)) {
+    throw new DeveloperError_default("boundingVolume is required.");
+  }
+  const planes = this.planes;
+  let intersecting = false;
+  for (let k = 0, len = planes.length; k < len; ++k) {
+    const result = boundingVolume.intersectPlane(
+      Plane_default.fromCartesian4(planes[k], scratchPlane)
+    );
+    if (result === Intersect_default.OUTSIDE) {
+      return Intersect_default.OUTSIDE;
+    } else if (result === Intersect_default.INTERSECTING) {
+      intersecting = true;
+    }
+  }
+  return intersecting ? Intersect_default.INTERSECTING : Intersect_default.INSIDE;
+};
+CullingVolume.prototype.computeVisibilityWithPlaneMask = function(boundingVolume, parentPlaneMask) {
+  if (!defined_default(boundingVolume)) {
+    throw new DeveloperError_default("boundingVolume is required.");
+  }
+  if (!defined_default(parentPlaneMask)) {
+    throw new DeveloperError_default("parentPlaneMask is required.");
+  }
+  if (parentPlaneMask === CullingVolume.MASK_OUTSIDE || parentPlaneMask === CullingVolume.MASK_INSIDE) {
+    return parentPlaneMask;
+  }
+  let mask = CullingVolume.MASK_INSIDE;
+  const planes = this.planes;
+  for (let k = 0, len = planes.length; k < len; ++k) {
+    const flag = k < 31 ? 1 << k : 0;
+    if (k < 31 && (parentPlaneMask & flag) === 0) {
+      continue;
+    }
+    const result = boundingVolume.intersectPlane(
+      Plane_default.fromCartesian4(planes[k], scratchPlane)
+    );
+    if (result === Intersect_default.OUTSIDE) {
+      return CullingVolume.MASK_OUTSIDE;
+    } else if (result === Intersect_default.INTERSECTING) {
+      mask |= flag;
+    }
+  }
+  return mask;
+};
+CullingVolume.MASK_OUTSIDE = 4294967295;
+CullingVolume.MASK_INSIDE = 0;
+CullingVolume.MASK_INDETERMINATE = 2147483647;
+var CullingVolume_default = CullingVolume;
+
+// packages/engine/Source/Core/OrthographicOffCenterFrustum.js
+function OrthographicOffCenterFrustum(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  this.left = options.left;
+  this._left = void 0;
+  this.right = options.right;
+  this._right = void 0;
+  this.top = options.top;
+  this._top = void 0;
+  this.bottom = options.bottom;
+  this._bottom = void 0;
+  this.near = defaultValue_default(options.near, 1);
+  this._near = this.near;
+  this.far = defaultValue_default(options.far, 5e8);
+  this._far = this.far;
+  this._cullingVolume = new CullingVolume_default();
+  this._orthographicMatrix = new Matrix4_default();
+}
+function update(frustum) {
+  if (!defined_default(frustum.right) || !defined_default(frustum.left) || !defined_default(frustum.top) || !defined_default(frustum.bottom) || !defined_default(frustum.near) || !defined_default(frustum.far)) {
+    throw new DeveloperError_default(
+      "right, left, top, bottom, near, or far parameters are not set."
+    );
+  }
+  if (frustum.top !== frustum._top || frustum.bottom !== frustum._bottom || frustum.left !== frustum._left || frustum.right !== frustum._right || frustum.near !== frustum._near || frustum.far !== frustum._far) {
+    if (frustum.left > frustum.right) {
+      throw new DeveloperError_default("right must be greater than left.");
+    }
+    if (frustum.bottom > frustum.top) {
+      throw new DeveloperError_default("top must be greater than bottom.");
+    }
+    if (frustum.near <= 0 || frustum.near > frustum.far) {
+      throw new DeveloperError_default(
+        "near must be greater than zero and less than far."
+      );
+    }
+    frustum._left = frustum.left;
+    frustum._right = frustum.right;
+    frustum._top = frustum.top;
+    frustum._bottom = frustum.bottom;
+    frustum._near = frustum.near;
+    frustum._far = frustum.far;
+    frustum._orthographicMatrix = Matrix4_default.computeOrthographicOffCenter(
+      frustum.left,
+      frustum.right,
+      frustum.bottom,
+      frustum.top,
+      frustum.near,
+      frustum.far,
+      frustum._orthographicMatrix
+    );
+  }
+}
+Object.defineProperties(OrthographicOffCenterFrustum.prototype, {
+  /**
+   * Gets the orthographic projection matrix computed from the view frustum.
+   * @memberof OrthographicOffCenterFrustum.prototype
+   * @type {Matrix4}
+   * @readonly
+   */
+  projectionMatrix: {
+    get: function() {
+      update(this);
+      return this._orthographicMatrix;
+    }
+  }
+});
+var getPlanesRight = new Cartesian3_default();
+var getPlanesNearCenter = new Cartesian3_default();
+var getPlanesPoint = new Cartesian3_default();
+var negateScratch = new Cartesian3_default();
+OrthographicOffCenterFrustum.prototype.computeCullingVolume = function(position, direction, up) {
+  if (!defined_default(position)) {
+    throw new DeveloperError_default("position is required.");
+  }
+  if (!defined_default(direction)) {
+    throw new DeveloperError_default("direction is required.");
+  }
+  if (!defined_default(up)) {
+    throw new DeveloperError_default("up is required.");
+  }
+  const planes = this._cullingVolume.planes;
+  const t = this.top;
+  const b = this.bottom;
+  const r = this.right;
+  const l = this.left;
+  const n = this.near;
+  const f = this.far;
+  const right = Cartesian3_default.cross(direction, up, getPlanesRight);
+  Cartesian3_default.normalize(right, right);
+  const nearCenter = getPlanesNearCenter;
+  Cartesian3_default.multiplyByScalar(direction, n, nearCenter);
+  Cartesian3_default.add(position, nearCenter, nearCenter);
+  const point = getPlanesPoint;
+  Cartesian3_default.multiplyByScalar(right, l, point);
+  Cartesian3_default.add(nearCenter, point, point);
+  let plane = planes[0];
+  if (!defined_default(plane)) {
+    plane = planes[0] = new Cartesian4_default();
+  }
+  plane.x = right.x;
+  plane.y = right.y;
+  plane.z = right.z;
+  plane.w = -Cartesian3_default.dot(right, point);
+  Cartesian3_default.multiplyByScalar(right, r, point);
+  Cartesian3_default.add(nearCenter, point, point);
+  plane = planes[1];
+  if (!defined_default(plane)) {
+    plane = planes[1] = new Cartesian4_default();
+  }
+  plane.x = -right.x;
+  plane.y = -right.y;
+  plane.z = -right.z;
+  plane.w = -Cartesian3_default.dot(Cartesian3_default.negate(right, negateScratch), point);
+  Cartesian3_default.multiplyByScalar(up, b, point);
+  Cartesian3_default.add(nearCenter, point, point);
+  plane = planes[2];
+  if (!defined_default(plane)) {
+    plane = planes[2] = new Cartesian4_default();
+  }
+  plane.x = up.x;
+  plane.y = up.y;
+  plane.z = up.z;
+  plane.w = -Cartesian3_default.dot(up, point);
+  Cartesian3_default.multiplyByScalar(up, t, point);
+  Cartesian3_default.add(nearCenter, point, point);
+  plane = planes[3];
+  if (!defined_default(plane)) {
+    plane = planes[3] = new Cartesian4_default();
+  }
+  plane.x = -up.x;
+  plane.y = -up.y;
+  plane.z = -up.z;
+  plane.w = -Cartesian3_default.dot(Cartesian3_default.negate(up, negateScratch), point);
+  plane = planes[4];
+  if (!defined_default(plane)) {
+    plane = planes[4] = new Cartesian4_default();
+  }
+  plane.x = direction.x;
+  plane.y = direction.y;
+  plane.z = direction.z;
+  plane.w = -Cartesian3_default.dot(direction, nearCenter);
+  Cartesian3_default.multiplyByScalar(direction, f, point);
+  Cartesian3_default.add(position, point, point);
+  plane = planes[5];
+  if (!defined_default(plane)) {
+    plane = planes[5] = new Cartesian4_default();
+  }
+  plane.x = -direction.x;
+  plane.y = -direction.y;
+  plane.z = -direction.z;
+  plane.w = -Cartesian3_default.dot(Cartesian3_default.negate(direction, negateScratch), point);
+  return this._cullingVolume;
+};
+OrthographicOffCenterFrustum.prototype.getPixelDimensions = function(drawingBufferWidth, drawingBufferHeight, distance, pixelRatio, result) {
+  update(this);
+  if (!defined_default(drawingBufferWidth) || !defined_default(drawingBufferHeight)) {
+    throw new DeveloperError_default(
+      "Both drawingBufferWidth and drawingBufferHeight are required."
+    );
+  }
+  if (drawingBufferWidth <= 0) {
+    throw new DeveloperError_default("drawingBufferWidth must be greater than zero.");
+  }
+  if (drawingBufferHeight <= 0) {
+    throw new DeveloperError_default("drawingBufferHeight must be greater than zero.");
+  }
+  if (!defined_default(distance)) {
+    throw new DeveloperError_default("distance is required.");
+  }
+  if (!defined_default(pixelRatio)) {
+    throw new DeveloperError_default("pixelRatio is required.");
+  }
+  if (pixelRatio <= 0) {
+    throw new DeveloperError_default("pixelRatio must be greater than zero.");
+  }
+  if (!defined_default(result)) {
+    throw new DeveloperError_default("A result object is required.");
+  }
+  const frustumWidth = this.right - this.left;
+  const frustumHeight = this.top - this.bottom;
+  const pixelWidth = pixelRatio * frustumWidth / drawingBufferWidth;
+  const pixelHeight = pixelRatio * frustumHeight / drawingBufferHeight;
+  result.x = pixelWidth;
+  result.y = pixelHeight;
+  return result;
+};
+OrthographicOffCenterFrustum.prototype.clone = function(result) {
+  if (!defined_default(result)) {
+    result = new OrthographicOffCenterFrustum();
+  }
+  result.left = this.left;
+  result.right = this.right;
+  result.top = this.top;
+  result.bottom = this.bottom;
+  result.near = this.near;
+  result.far = this.far;
+  result._left = void 0;
+  result._right = void 0;
+  result._top = void 0;
+  result._bottom = void 0;
+  result._near = void 0;
+  result._far = void 0;
+  return result;
+};
+OrthographicOffCenterFrustum.prototype.equals = function(other) {
+  return defined_default(other) && other instanceof OrthographicOffCenterFrustum && this.right === other.right && this.left === other.left && this.top === other.top && this.bottom === other.bottom && this.near === other.near && this.far === other.far;
+};
+OrthographicOffCenterFrustum.prototype.equalsEpsilon = function(other, relativeEpsilon, absoluteEpsilon) {
+  return other === this || defined_default(other) && other instanceof OrthographicOffCenterFrustum && Math_default.equalsEpsilon(
+    this.right,
+    other.right,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    this.left,
+    other.left,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    this.top,
+    other.top,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    this.bottom,
+    other.bottom,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    this.near,
+    other.near,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    this.far,
+    other.far,
+    relativeEpsilon,
+    absoluteEpsilon
+  );
+};
+var OrthographicOffCenterFrustum_default = OrthographicOffCenterFrustum;
+
+// packages/engine/Source/Core/OrthographicFrustum.js
+function OrthographicFrustum(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  this._offCenterFrustum = new OrthographicOffCenterFrustum_default();
+  this.width = options.width;
+  this._width = void 0;
+  this.aspectRatio = options.aspectRatio;
+  this._aspectRatio = void 0;
+  this.near = defaultValue_default(options.near, 1);
+  this._near = this.near;
+  this.far = defaultValue_default(options.far, 5e8);
+  this._far = this.far;
+}
+OrthographicFrustum.packedLength = 4;
+OrthographicFrustum.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  array[startingIndex++] = value.width;
+  array[startingIndex++] = value.aspectRatio;
+  array[startingIndex++] = value.near;
+  array[startingIndex] = value.far;
+  return array;
+};
+OrthographicFrustum.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  if (!defined_default(result)) {
+    result = new OrthographicFrustum();
+  }
+  result.width = array[startingIndex++];
+  result.aspectRatio = array[startingIndex++];
+  result.near = array[startingIndex++];
+  result.far = array[startingIndex];
+  return result;
+};
+function update2(frustum) {
+  if (!defined_default(frustum.width) || !defined_default(frustum.aspectRatio) || !defined_default(frustum.near) || !defined_default(frustum.far)) {
+    throw new DeveloperError_default(
+      "width, aspectRatio, near, or far parameters are not set."
+    );
+  }
+  const f = frustum._offCenterFrustum;
+  if (frustum.width !== frustum._width || frustum.aspectRatio !== frustum._aspectRatio || frustum.near !== frustum._near || frustum.far !== frustum._far) {
+    if (frustum.aspectRatio < 0) {
+      throw new DeveloperError_default("aspectRatio must be positive.");
+    }
+    if (frustum.near < 0 || frustum.near > frustum.far) {
+      throw new DeveloperError_default(
+        "near must be greater than zero and less than far."
+      );
+    }
+    frustum._aspectRatio = frustum.aspectRatio;
+    frustum._width = frustum.width;
+    frustum._near = frustum.near;
+    frustum._far = frustum.far;
+    const ratio = 1 / frustum.aspectRatio;
+    f.right = frustum.width * 0.5;
+    f.left = -f.right;
+    f.top = ratio * f.right;
+    f.bottom = -f.top;
+    f.near = frustum.near;
+    f.far = frustum.far;
+  }
+}
+Object.defineProperties(OrthographicFrustum.prototype, {
+  /**
+   * Gets the orthographic projection matrix computed from the view frustum.
+   * @memberof OrthographicFrustum.prototype
+   * @type {Matrix4}
+   * @readonly
+   */
+  projectionMatrix: {
+    get: function() {
+      update2(this);
+      return this._offCenterFrustum.projectionMatrix;
+    }
+  },
+  /**
+   * Gets the orthographic projection matrix computed from the view frustum.
+   * @memberof OrthographicFrustum.prototype
+   * @type {OrthographicOffCenterFrustum}
+   * @readonly
+   * @private
+   */
+  offCenterFrustum: {
+    get: function() {
+      update2(this);
+      return this._offCenterFrustum;
+    }
+  }
+});
+OrthographicFrustum.prototype.computeCullingVolume = function(position, direction, up) {
+  update2(this);
+  return this._offCenterFrustum.computeCullingVolume(position, direction, up);
+};
+OrthographicFrustum.prototype.getPixelDimensions = function(drawingBufferWidth, drawingBufferHeight, distance, pixelRatio, result) {
+  update2(this);
+  return this._offCenterFrustum.getPixelDimensions(
+    drawingBufferWidth,
+    drawingBufferHeight,
+    distance,
+    pixelRatio,
+    result
+  );
+};
+OrthographicFrustum.prototype.clone = function(result) {
+  if (!defined_default(result)) {
+    result = new OrthographicFrustum();
+  }
+  result.aspectRatio = this.aspectRatio;
+  result.width = this.width;
+  result.near = this.near;
+  result.far = this.far;
+  result._aspectRatio = void 0;
+  result._width = void 0;
+  result._near = void 0;
+  result._far = void 0;
+  this._offCenterFrustum.clone(result._offCenterFrustum);
+  return result;
+};
+OrthographicFrustum.prototype.equals = function(other) {
+  if (!defined_default(other) || !(other instanceof OrthographicFrustum)) {
+    return false;
+  }
+  update2(this);
+  update2(other);
+  return this.width === other.width && this.aspectRatio === other.aspectRatio && this._offCenterFrustum.equals(other._offCenterFrustum);
+};
+OrthographicFrustum.prototype.equalsEpsilon = function(other, relativeEpsilon, absoluteEpsilon) {
+  if (!defined_default(other) || !(other instanceof OrthographicFrustum)) {
+    return false;
+  }
+  update2(this);
+  update2(other);
+  return Math_default.equalsEpsilon(
+    this.width,
+    other.width,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    this.aspectRatio,
+    other.aspectRatio,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && this._offCenterFrustum.equalsEpsilon(
+    other._offCenterFrustum,
+    relativeEpsilon,
+    absoluteEpsilon
+  );
+};
+var OrthographicFrustum_default = OrthographicFrustum;
+
+// packages/engine/Source/Core/PerspectiveOffCenterFrustum.js
+function PerspectiveOffCenterFrustum(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  this.left = options.left;
+  this._left = void 0;
+  this.right = options.right;
+  this._right = void 0;
+  this.top = options.top;
+  this._top = void 0;
+  this.bottom = options.bottom;
+  this._bottom = void 0;
+  this.near = defaultValue_default(options.near, 1);
+  this._near = this.near;
+  this.far = defaultValue_default(options.far, 5e8);
+  this._far = this.far;
+  this._cullingVolume = new CullingVolume_default();
+  this._perspectiveMatrix = new Matrix4_default();
+  this._infinitePerspective = new Matrix4_default();
+}
+function update3(frustum) {
+  if (!defined_default(frustum.right) || !defined_default(frustum.left) || !defined_default(frustum.top) || !defined_default(frustum.bottom) || !defined_default(frustum.near) || !defined_default(frustum.far)) {
+    throw new DeveloperError_default(
+      "right, left, top, bottom, near, or far parameters are not set."
+    );
+  }
+  const t = frustum.top;
+  const b = frustum.bottom;
+  const r = frustum.right;
+  const l = frustum.left;
+  const n = frustum.near;
+  const f = frustum.far;
+  if (t !== frustum._top || b !== frustum._bottom || l !== frustum._left || r !== frustum._right || n !== frustum._near || f !== frustum._far) {
+    if (frustum.near <= 0 || frustum.near > frustum.far) {
+      throw new DeveloperError_default(
+        "near must be greater than zero and less than far."
+      );
+    }
+    frustum._left = l;
+    frustum._right = r;
+    frustum._top = t;
+    frustum._bottom = b;
+    frustum._near = n;
+    frustum._far = f;
+    frustum._perspectiveMatrix = Matrix4_default.computePerspectiveOffCenter(
+      l,
+      r,
+      b,
+      t,
+      n,
+      f,
+      frustum._perspectiveMatrix
+    );
+    frustum._infinitePerspective = Matrix4_default.computeInfinitePerspectiveOffCenter(
+      l,
+      r,
+      b,
+      t,
+      n,
+      frustum._infinitePerspective
+    );
+  }
+}
+Object.defineProperties(PerspectiveOffCenterFrustum.prototype, {
+  /**
+   * Gets the perspective projection matrix computed from the view frustum.
+   * @memberof PerspectiveOffCenterFrustum.prototype
+   * @type {Matrix4}
+   * @readonly
+   *
+   * @see PerspectiveOffCenterFrustum#infiniteProjectionMatrix
+   */
+  projectionMatrix: {
+    get: function() {
+      update3(this);
+      return this._perspectiveMatrix;
+    }
+  },
+  /**
+   * Gets the perspective projection matrix computed from the view frustum with an infinite far plane.
+   * @memberof PerspectiveOffCenterFrustum.prototype
+   * @type {Matrix4}
+   * @readonly
+   *
+   * @see PerspectiveOffCenterFrustum#projectionMatrix
+   */
+  infiniteProjectionMatrix: {
+    get: function() {
+      update3(this);
+      return this._infinitePerspective;
+    }
+  }
+});
+var getPlanesRight2 = new Cartesian3_default();
+var getPlanesNearCenter2 = new Cartesian3_default();
+var getPlanesFarCenter = new Cartesian3_default();
+var getPlanesNormal = new Cartesian3_default();
+PerspectiveOffCenterFrustum.prototype.computeCullingVolume = function(position, direction, up) {
+  if (!defined_default(position)) {
+    throw new DeveloperError_default("position is required.");
+  }
+  if (!defined_default(direction)) {
+    throw new DeveloperError_default("direction is required.");
+  }
+  if (!defined_default(up)) {
+    throw new DeveloperError_default("up is required.");
+  }
+  const planes = this._cullingVolume.planes;
+  const t = this.top;
+  const b = this.bottom;
+  const r = this.right;
+  const l = this.left;
+  const n = this.near;
+  const f = this.far;
+  const right = Cartesian3_default.cross(direction, up, getPlanesRight2);
+  const nearCenter = getPlanesNearCenter2;
+  Cartesian3_default.multiplyByScalar(direction, n, nearCenter);
+  Cartesian3_default.add(position, nearCenter, nearCenter);
+  const farCenter = getPlanesFarCenter;
+  Cartesian3_default.multiplyByScalar(direction, f, farCenter);
+  Cartesian3_default.add(position, farCenter, farCenter);
+  const normal = getPlanesNormal;
+  Cartesian3_default.multiplyByScalar(right, l, normal);
+  Cartesian3_default.add(nearCenter, normal, normal);
+  Cartesian3_default.subtract(normal, position, normal);
+  Cartesian3_default.normalize(normal, normal);
+  Cartesian3_default.cross(normal, up, normal);
+  Cartesian3_default.normalize(normal, normal);
+  let plane = planes[0];
+  if (!defined_default(plane)) {
+    plane = planes[0] = new Cartesian4_default();
+  }
+  plane.x = normal.x;
+  plane.y = normal.y;
+  plane.z = normal.z;
+  plane.w = -Cartesian3_default.dot(normal, position);
+  Cartesian3_default.multiplyByScalar(right, r, normal);
+  Cartesian3_default.add(nearCenter, normal, normal);
+  Cartesian3_default.subtract(normal, position, normal);
+  Cartesian3_default.cross(up, normal, normal);
+  Cartesian3_default.normalize(normal, normal);
+  plane = planes[1];
+  if (!defined_default(plane)) {
+    plane = planes[1] = new Cartesian4_default();
+  }
+  plane.x = normal.x;
+  plane.y = normal.y;
+  plane.z = normal.z;
+  plane.w = -Cartesian3_default.dot(normal, position);
+  Cartesian3_default.multiplyByScalar(up, b, normal);
+  Cartesian3_default.add(nearCenter, normal, normal);
+  Cartesian3_default.subtract(normal, position, normal);
+  Cartesian3_default.cross(right, normal, normal);
+  Cartesian3_default.normalize(normal, normal);
+  plane = planes[2];
+  if (!defined_default(plane)) {
+    plane = planes[2] = new Cartesian4_default();
+  }
+  plane.x = normal.x;
+  plane.y = normal.y;
+  plane.z = normal.z;
+  plane.w = -Cartesian3_default.dot(normal, position);
+  Cartesian3_default.multiplyByScalar(up, t, normal);
+  Cartesian3_default.add(nearCenter, normal, normal);
+  Cartesian3_default.subtract(normal, position, normal);
+  Cartesian3_default.cross(normal, right, normal);
+  Cartesian3_default.normalize(normal, normal);
+  plane = planes[3];
+  if (!defined_default(plane)) {
+    plane = planes[3] = new Cartesian4_default();
+  }
+  plane.x = normal.x;
+  plane.y = normal.y;
+  plane.z = normal.z;
+  plane.w = -Cartesian3_default.dot(normal, position);
+  plane = planes[4];
+  if (!defined_default(plane)) {
+    plane = planes[4] = new Cartesian4_default();
+  }
+  plane.x = direction.x;
+  plane.y = direction.y;
+  plane.z = direction.z;
+  plane.w = -Cartesian3_default.dot(direction, nearCenter);
+  Cartesian3_default.negate(direction, normal);
+  plane = planes[5];
+  if (!defined_default(plane)) {
+    plane = planes[5] = new Cartesian4_default();
+  }
+  plane.x = normal.x;
+  plane.y = normal.y;
+  plane.z = normal.z;
+  plane.w = -Cartesian3_default.dot(normal, farCenter);
+  return this._cullingVolume;
+};
+PerspectiveOffCenterFrustum.prototype.getPixelDimensions = function(drawingBufferWidth, drawingBufferHeight, distance, pixelRatio, result) {
+  update3(this);
+  if (!defined_default(drawingBufferWidth) || !defined_default(drawingBufferHeight)) {
+    throw new DeveloperError_default(
+      "Both drawingBufferWidth and drawingBufferHeight are required."
+    );
+  }
+  if (drawingBufferWidth <= 0) {
+    throw new DeveloperError_default("drawingBufferWidth must be greater than zero.");
+  }
+  if (drawingBufferHeight <= 0) {
+    throw new DeveloperError_default("drawingBufferHeight must be greater than zero.");
+  }
+  if (!defined_default(distance)) {
+    throw new DeveloperError_default("distance is required.");
+  }
+  if (!defined_default(pixelRatio)) {
+    throw new DeveloperError_default("pixelRatio is required");
+  }
+  if (pixelRatio <= 0) {
+    throw new DeveloperError_default("pixelRatio must be greater than zero.");
+  }
+  if (!defined_default(result)) {
+    throw new DeveloperError_default("A result object is required.");
+  }
+  const inverseNear = 1 / this.near;
+  let tanTheta = this.top * inverseNear;
+  const pixelHeight = 2 * pixelRatio * distance * tanTheta / drawingBufferHeight;
+  tanTheta = this.right * inverseNear;
+  const pixelWidth = 2 * pixelRatio * distance * tanTheta / drawingBufferWidth;
+  result.x = pixelWidth;
+  result.y = pixelHeight;
+  return result;
+};
+PerspectiveOffCenterFrustum.prototype.clone = function(result) {
+  if (!defined_default(result)) {
+    result = new PerspectiveOffCenterFrustum();
+  }
+  result.right = this.right;
+  result.left = this.left;
+  result.top = this.top;
+  result.bottom = this.bottom;
+  result.near = this.near;
+  result.far = this.far;
+  result._left = void 0;
+  result._right = void 0;
+  result._top = void 0;
+  result._bottom = void 0;
+  result._near = void 0;
+  result._far = void 0;
+  return result;
+};
+PerspectiveOffCenterFrustum.prototype.equals = function(other) {
+  return defined_default(other) && other instanceof PerspectiveOffCenterFrustum && this.right === other.right && this.left === other.left && this.top === other.top && this.bottom === other.bottom && this.near === other.near && this.far === other.far;
+};
+PerspectiveOffCenterFrustum.prototype.equalsEpsilon = function(other, relativeEpsilon, absoluteEpsilon) {
+  return other === this || defined_default(other) && other instanceof PerspectiveOffCenterFrustum && Math_default.equalsEpsilon(
+    this.right,
+    other.right,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    this.left,
+    other.left,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    this.top,
+    other.top,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    this.bottom,
+    other.bottom,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    this.near,
+    other.near,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    this.far,
+    other.far,
+    relativeEpsilon,
+    absoluteEpsilon
+  );
+};
+var PerspectiveOffCenterFrustum_default = PerspectiveOffCenterFrustum;
+
+// packages/engine/Source/Core/PerspectiveFrustum.js
+function PerspectiveFrustum(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  this._offCenterFrustum = new PerspectiveOffCenterFrustum_default();
+  this.fov = options.fov;
+  this._fov = void 0;
+  this._fovy = void 0;
+  this._sseDenominator = void 0;
+  this.aspectRatio = options.aspectRatio;
+  this._aspectRatio = void 0;
+  this.near = defaultValue_default(options.near, 1);
+  this._near = this.near;
+  this.far = defaultValue_default(options.far, 5e8);
+  this._far = this.far;
+  this.xOffset = defaultValue_default(options.xOffset, 0);
+  this._xOffset = this.xOffset;
+  this.yOffset = defaultValue_default(options.yOffset, 0);
+  this._yOffset = this.yOffset;
+}
+PerspectiveFrustum.packedLength = 6;
+PerspectiveFrustum.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  array[startingIndex++] = value.fov;
+  array[startingIndex++] = value.aspectRatio;
+  array[startingIndex++] = value.near;
+  array[startingIndex++] = value.far;
+  array[startingIndex++] = value.xOffset;
+  array[startingIndex] = value.yOffset;
+  return array;
+};
+PerspectiveFrustum.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  if (!defined_default(result)) {
+    result = new PerspectiveFrustum();
+  }
+  result.fov = array[startingIndex++];
+  result.aspectRatio = array[startingIndex++];
+  result.near = array[startingIndex++];
+  result.far = array[startingIndex++];
+  result.xOffset = array[startingIndex++];
+  result.yOffset = array[startingIndex];
+  return result;
+};
+function update4(frustum) {
+  if (!defined_default(frustum.fov) || !defined_default(frustum.aspectRatio) || !defined_default(frustum.near) || !defined_default(frustum.far)) {
+    throw new DeveloperError_default(
+      "fov, aspectRatio, near, or far parameters are not set."
+    );
+  }
+  const f = frustum._offCenterFrustum;
+  if (frustum.fov !== frustum._fov || frustum.aspectRatio !== frustum._aspectRatio || frustum.near !== frustum._near || frustum.far !== frustum._far || frustum.xOffset !== frustum._xOffset || frustum.yOffset !== frustum._yOffset) {
+    if (frustum.fov < 0 || frustum.fov >= Math.PI) {
+      throw new DeveloperError_default("fov must be in the range [0, PI).");
+    }
+    if (frustum.aspectRatio < 0) {
+      throw new DeveloperError_default("aspectRatio must be positive.");
+    }
+    if (frustum.near < 0 || frustum.near > frustum.far) {
+      throw new DeveloperError_default(
+        "near must be greater than zero and less than far."
+      );
+    }
+    frustum._aspectRatio = frustum.aspectRatio;
+    frustum._fov = frustum.fov;
+    frustum._fovy = frustum.aspectRatio <= 1 ? frustum.fov : Math.atan(Math.tan(frustum.fov * 0.5) / frustum.aspectRatio) * 2;
+    frustum._near = frustum.near;
+    frustum._far = frustum.far;
+    frustum._sseDenominator = 2 * Math.tan(0.5 * frustum._fovy);
+    frustum._xOffset = frustum.xOffset;
+    frustum._yOffset = frustum.yOffset;
+    f.top = frustum.near * Math.tan(0.5 * frustum._fovy);
+    f.bottom = -f.top;
+    f.right = frustum.aspectRatio * f.top;
+    f.left = -f.right;
+    f.near = frustum.near;
+    f.far = frustum.far;
+    f.right += frustum.xOffset;
+    f.left += frustum.xOffset;
+    f.top += frustum.yOffset;
+    f.bottom += frustum.yOffset;
+  }
+}
+Object.defineProperties(PerspectiveFrustum.prototype, {
+  /**
+   * Gets the perspective projection matrix computed from the view frustum.
+   * @memberof PerspectiveFrustum.prototype
+   * @type {Matrix4}
+   * @readonly
+   *
+   * @see PerspectiveFrustum#infiniteProjectionMatrix
+   */
+  projectionMatrix: {
+    get: function() {
+      update4(this);
+      return this._offCenterFrustum.projectionMatrix;
+    }
+  },
+  /**
+   * The perspective projection matrix computed from the view frustum with an infinite far plane.
+   * @memberof PerspectiveFrustum.prototype
+   * @type {Matrix4}
+   * @readonly
+   *
+   * @see PerspectiveFrustum#projectionMatrix
+   */
+  infiniteProjectionMatrix: {
+    get: function() {
+      update4(this);
+      return this._offCenterFrustum.infiniteProjectionMatrix;
+    }
+  },
+  /**
+   * Gets the angle of the vertical field of view, in radians.
+   * @memberof PerspectiveFrustum.prototype
+   * @type {number}
+   * @readonly
+   * @default undefined
+   */
+  fovy: {
+    get: function() {
+      update4(this);
+      return this._fovy;
+    }
+  },
+  /**
+   * @readonly
+   * @private
+   */
+  sseDenominator: {
+    get: function() {
+      update4(this);
+      return this._sseDenominator;
+    }
+  },
+  /**
+   * Gets the orthographic projection matrix computed from the view frustum.
+   * @memberof PerspectiveFrustum.prototype
+   * @type {PerspectiveOffCenterFrustum}
+   * @readonly
+   * @private
+   */
+  offCenterFrustum: {
+    get: function() {
+      update4(this);
+      return this._offCenterFrustum;
+    }
+  }
+});
+PerspectiveFrustum.prototype.computeCullingVolume = function(position, direction, up) {
+  update4(this);
+  return this._offCenterFrustum.computeCullingVolume(position, direction, up);
+};
+PerspectiveFrustum.prototype.getPixelDimensions = function(drawingBufferWidth, drawingBufferHeight, distance, pixelRatio, result) {
+  update4(this);
+  return this._offCenterFrustum.getPixelDimensions(
+    drawingBufferWidth,
+    drawingBufferHeight,
+    distance,
+    pixelRatio,
+    result
+  );
+};
+PerspectiveFrustum.prototype.clone = function(result) {
+  if (!defined_default(result)) {
+    result = new PerspectiveFrustum();
+  }
+  result.aspectRatio = this.aspectRatio;
+  result.fov = this.fov;
+  result.near = this.near;
+  result.far = this.far;
+  result._aspectRatio = void 0;
+  result._fov = void 0;
+  result._near = void 0;
+  result._far = void 0;
+  this._offCenterFrustum.clone(result._offCenterFrustum);
+  return result;
+};
+PerspectiveFrustum.prototype.equals = function(other) {
+  if (!defined_default(other) || !(other instanceof PerspectiveFrustum)) {
+    return false;
+  }
+  update4(this);
+  update4(other);
+  return this.fov === other.fov && this.aspectRatio === other.aspectRatio && this._offCenterFrustum.equals(other._offCenterFrustum);
+};
+PerspectiveFrustum.prototype.equalsEpsilon = function(other, relativeEpsilon, absoluteEpsilon) {
+  if (!defined_default(other) || !(other instanceof PerspectiveFrustum)) {
+    return false;
+  }
+  update4(this);
+  update4(other);
+  return Math_default.equalsEpsilon(
+    this.fov,
+    other.fov,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    this.aspectRatio,
+    other.aspectRatio,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && this._offCenterFrustum.equalsEpsilon(
+    other._offCenterFrustum,
+    relativeEpsilon,
+    absoluteEpsilon
+  );
+};
+var PerspectiveFrustum_default = PerspectiveFrustum;
+
+// packages/engine/Source/Core/FrustumGeometry.js
+var PERSPECTIVE = 0;
+var ORTHOGRAPHIC = 1;
+function FrustumGeometry(options) {
+  Check_default.typeOf.object("options", options);
+  Check_default.typeOf.object("options.frustum", options.frustum);
+  Check_default.typeOf.object("options.origin", options.origin);
+  Check_default.typeOf.object("options.orientation", options.orientation);
+  const frustum = options.frustum;
+  const orientation = options.orientation;
+  const origin = options.origin;
+  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
+  const drawNearPlane = defaultValue_default(options._drawNearPlane, true);
+  let frustumType;
+  let frustumPackedLength;
+  if (frustum instanceof PerspectiveFrustum_default) {
+    frustumType = PERSPECTIVE;
+    frustumPackedLength = PerspectiveFrustum_default.packedLength;
+  } else if (frustum instanceof OrthographicFrustum_default) {
+    frustumType = ORTHOGRAPHIC;
+    frustumPackedLength = OrthographicFrustum_default.packedLength;
+  }
+  this._frustumType = frustumType;
+  this._frustum = frustum.clone();
+  this._origin = Cartesian3_default.clone(origin);
+  this._orientation = Quaternion_default.clone(orientation);
+  this._drawNearPlane = drawNearPlane;
+  this._vertexFormat = vertexFormat;
+  this._workerName = "createFrustumGeometry";
+  this.packedLength = 2 + frustumPackedLength + Cartesian3_default.packedLength + Quaternion_default.packedLength + VertexFormat_default.packedLength;
+}
+FrustumGeometry.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const frustumType = value._frustumType;
+  const frustum = value._frustum;
+  array[startingIndex++] = frustumType;
+  if (frustumType === PERSPECTIVE) {
+    PerspectiveFrustum_default.pack(frustum, array, startingIndex);
+    startingIndex += PerspectiveFrustum_default.packedLength;
+  } else {
+    OrthographicFrustum_default.pack(frustum, array, startingIndex);
+    startingIndex += OrthographicFrustum_default.packedLength;
+  }
+  Cartesian3_default.pack(value._origin, array, startingIndex);
+  startingIndex += Cartesian3_default.packedLength;
+  Quaternion_default.pack(value._orientation, array, startingIndex);
+  startingIndex += Quaternion_default.packedLength;
+  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
+  startingIndex += VertexFormat_default.packedLength;
+  array[startingIndex] = value._drawNearPlane ? 1 : 0;
+  return array;
+};
+var scratchPackPerspective = new PerspectiveFrustum_default();
+var scratchPackOrthographic = new OrthographicFrustum_default();
+var scratchPackQuaternion = new Quaternion_default();
+var scratchPackorigin = new Cartesian3_default();
+var scratchVertexFormat = new VertexFormat_default();
+FrustumGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const frustumType = array[startingIndex++];
+  let frustum;
+  if (frustumType === PERSPECTIVE) {
+    frustum = PerspectiveFrustum_default.unpack(
+      array,
+      startingIndex,
+      scratchPackPerspective
+    );
+    startingIndex += PerspectiveFrustum_default.packedLength;
+  } else {
+    frustum = OrthographicFrustum_default.unpack(
+      array,
+      startingIndex,
+      scratchPackOrthographic
+    );
+    startingIndex += OrthographicFrustum_default.packedLength;
+  }
+  const origin = Cartesian3_default.unpack(array, startingIndex, scratchPackorigin);
+  startingIndex += Cartesian3_default.packedLength;
+  const orientation = Quaternion_default.unpack(
+    array,
+    startingIndex,
+    scratchPackQuaternion
+  );
+  startingIndex += Quaternion_default.packedLength;
+  const vertexFormat = VertexFormat_default.unpack(
+    array,
+    startingIndex,
+    scratchVertexFormat
+  );
+  startingIndex += VertexFormat_default.packedLength;
+  const drawNearPlane = array[startingIndex] === 1;
+  if (!defined_default(result)) {
+    return new FrustumGeometry({
+      frustum,
+      origin,
+      orientation,
+      vertexFormat,
+      _drawNearPlane: drawNearPlane
+    });
+  }
+  const frustumResult = frustumType === result._frustumType ? result._frustum : void 0;
+  result._frustum = frustum.clone(frustumResult);
+  result._frustumType = frustumType;
+  result._origin = Cartesian3_default.clone(origin, result._origin);
+  result._orientation = Quaternion_default.clone(orientation, result._orientation);
+  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
+  result._drawNearPlane = drawNearPlane;
+  return result;
+};
+function getAttributes(offset, normals, tangents, bitangents, st, normal, tangent, bitangent) {
+  const stOffset = offset / 3 * 2;
+  for (let i = 0; i < 4; ++i) {
+    if (defined_default(normals)) {
+      normals[offset] = normal.x;
+      normals[offset + 1] = normal.y;
+      normals[offset + 2] = normal.z;
+    }
+    if (defined_default(tangents)) {
+      tangents[offset] = tangent.x;
+      tangents[offset + 1] = tangent.y;
+      tangents[offset + 2] = tangent.z;
+    }
+    if (defined_default(bitangents)) {
+      bitangents[offset] = bitangent.x;
+      bitangents[offset + 1] = bitangent.y;
+      bitangents[offset + 2] = bitangent.z;
+    }
+    offset += 3;
+  }
+  st[stOffset] = 0;
+  st[stOffset + 1] = 0;
+  st[stOffset + 2] = 1;
+  st[stOffset + 3] = 0;
+  st[stOffset + 4] = 1;
+  st[stOffset + 5] = 1;
+  st[stOffset + 6] = 0;
+  st[stOffset + 7] = 1;
+}
+var scratchRotationMatrix = new Matrix3_default();
+var scratchViewMatrix = new Matrix4_default();
+var scratchInverseMatrix = new Matrix4_default();
+var scratchXDirection = new Cartesian3_default();
+var scratchYDirection = new Cartesian3_default();
+var scratchZDirection = new Cartesian3_default();
+var scratchNegativeX = new Cartesian3_default();
+var scratchNegativeY = new Cartesian3_default();
+var scratchNegativeZ = new Cartesian3_default();
+var frustumSplits = new Array(3);
+var frustumCornersNDC = new Array(4);
+frustumCornersNDC[0] = new Cartesian4_default(-1, -1, 1, 1);
+frustumCornersNDC[1] = new Cartesian4_default(1, -1, 1, 1);
+frustumCornersNDC[2] = new Cartesian4_default(1, 1, 1, 1);
+frustumCornersNDC[3] = new Cartesian4_default(-1, 1, 1, 1);
+var scratchFrustumCorners = new Array(4);
+for (let i = 0; i < 4; ++i) {
+  scratchFrustumCorners[i] = new Cartesian4_default();
+}
+FrustumGeometry._computeNearFarPlanes = function(origin, orientation, frustumType, frustum, positions, xDirection, yDirection, zDirection) {
+  const rotationMatrix = Matrix3_default.fromQuaternion(
+    orientation,
+    scratchRotationMatrix
+  );
+  let x = defaultValue_default(xDirection, scratchXDirection);
+  let y = defaultValue_default(yDirection, scratchYDirection);
+  let z = defaultValue_default(zDirection, scratchZDirection);
+  x = Matrix3_default.getColumn(rotationMatrix, 0, x);
+  y = Matrix3_default.getColumn(rotationMatrix, 1, y);
+  z = Matrix3_default.getColumn(rotationMatrix, 2, z);
+  Cartesian3_default.normalize(x, x);
+  Cartesian3_default.normalize(y, y);
+  Cartesian3_default.normalize(z, z);
+  Cartesian3_default.negate(x, x);
+  const view = Matrix4_default.computeView(origin, z, y, x, scratchViewMatrix);
+  let inverseView;
+  let inverseViewProjection;
+  const projection = frustum.projectionMatrix;
+  if (frustumType === PERSPECTIVE) {
+    const viewProjection = Matrix4_default.multiply(
+      projection,
+      view,
+      scratchInverseMatrix
+    );
+    inverseViewProjection = Matrix4_default.inverse(
+      viewProjection,
+      scratchInverseMatrix
+    );
+  } else {
+    inverseView = Matrix4_default.inverseTransformation(view, scratchInverseMatrix);
+  }
+  if (defined_default(inverseViewProjection)) {
+    frustumSplits[0] = frustum.near;
+    frustumSplits[1] = frustum.far;
+  } else {
+    frustumSplits[0] = 0;
+    frustumSplits[1] = frustum.near;
+    frustumSplits[2] = frustum.far;
+  }
+  for (let i = 0; i < 2; ++i) {
+    for (let j = 0; j < 4; ++j) {
+      let corner = Cartesian4_default.clone(
+        frustumCornersNDC[j],
+        scratchFrustumCorners[j]
+      );
+      if (!defined_default(inverseViewProjection)) {
+        const offCenterFrustum = frustum.offCenterFrustum;
+        if (defined_default(offCenterFrustum)) {
+          frustum = offCenterFrustum;
+        }
+        const near = frustumSplits[i];
+        const far = frustumSplits[i + 1];
+        corner.x = (corner.x * (frustum.right - frustum.left) + frustum.left + frustum.right) * 0.5;
+        corner.y = (corner.y * (frustum.top - frustum.bottom) + frustum.bottom + frustum.top) * 0.5;
+        corner.z = (corner.z * (near - far) - near - far) * 0.5;
+        corner.w = 1;
+        Matrix4_default.multiplyByVector(inverseView, corner, corner);
+      } else {
+        corner = Matrix4_default.multiplyByVector(
+          inverseViewProjection,
+          corner,
+          corner
+        );
+        const w = 1 / corner.w;
+        Cartesian3_default.multiplyByScalar(corner, w, corner);
+        Cartesian3_default.subtract(corner, origin, corner);
+        Cartesian3_default.normalize(corner, corner);
+        const fac = Cartesian3_default.dot(z, corner);
+        Cartesian3_default.multiplyByScalar(corner, frustumSplits[i] / fac, corner);
+        Cartesian3_default.add(corner, origin, corner);
+      }
+      positions[12 * i + j * 3] = corner.x;
+      positions[12 * i + j * 3 + 1] = corner.y;
+      positions[12 * i + j * 3 + 2] = corner.z;
+    }
+  }
+};
+FrustumGeometry.createGeometry = function(frustumGeometry) {
+  const frustumType = frustumGeometry._frustumType;
+  const frustum = frustumGeometry._frustum;
+  const origin = frustumGeometry._origin;
+  const orientation = frustumGeometry._orientation;
+  const drawNearPlane = frustumGeometry._drawNearPlane;
+  const vertexFormat = frustumGeometry._vertexFormat;
+  const numberOfPlanes = drawNearPlane ? 6 : 5;
+  let positions = new Float64Array(3 * 4 * 6);
+  FrustumGeometry._computeNearFarPlanes(
+    origin,
+    orientation,
+    frustumType,
+    frustum,
+    positions
+  );
+  let offset = 3 * 4 * 2;
+  positions[offset] = positions[3 * 4];
+  positions[offset + 1] = positions[3 * 4 + 1];
+  positions[offset + 2] = positions[3 * 4 + 2];
+  positions[offset + 3] = positions[0];
+  positions[offset + 4] = positions[1];
+  positions[offset + 5] = positions[2];
+  positions[offset + 6] = positions[3 * 3];
+  positions[offset + 7] = positions[3 * 3 + 1];
+  positions[offset + 8] = positions[3 * 3 + 2];
+  positions[offset + 9] = positions[3 * 7];
+  positions[offset + 10] = positions[3 * 7 + 1];
+  positions[offset + 11] = positions[3 * 7 + 2];
+  offset += 3 * 4;
+  positions[offset] = positions[3 * 5];
+  positions[offset + 1] = positions[3 * 5 + 1];
+  positions[offset + 2] = positions[3 * 5 + 2];
+  positions[offset + 3] = positions[3];
+  positions[offset + 4] = positions[3 + 1];
+  positions[offset + 5] = positions[3 + 2];
+  positions[offset + 6] = positions[0];
+  positions[offset + 7] = positions[1];
+  positions[offset + 8] = positions[2];
+  positions[offset + 9] = positions[3 * 4];
+  positions[offset + 10] = positions[3 * 4 + 1];
+  positions[offset + 11] = positions[3 * 4 + 2];
+  offset += 3 * 4;
+  positions[offset] = positions[3];
+  positions[offset + 1] = positions[3 + 1];
+  positions[offset + 2] = positions[3 + 2];
+  positions[offset + 3] = positions[3 * 5];
+  positions[offset + 4] = positions[3 * 5 + 1];
+  positions[offset + 5] = positions[3 * 5 + 2];
+  positions[offset + 6] = positions[3 * 6];
+  positions[offset + 7] = positions[3 * 6 + 1];
+  positions[offset + 8] = positions[3 * 6 + 2];
+  positions[offset + 9] = positions[3 * 2];
+  positions[offset + 10] = positions[3 * 2 + 1];
+  positions[offset + 11] = positions[3 * 2 + 2];
+  offset += 3 * 4;
+  positions[offset] = positions[3 * 2];
+  positions[offset + 1] = positions[3 * 2 + 1];
+  positions[offset + 2] = positions[3 * 2 + 2];
+  positions[offset + 3] = positions[3 * 6];
+  positions[offset + 4] = positions[3 * 6 + 1];
+  positions[offset + 5] = positions[3 * 6 + 2];
+  positions[offset + 6] = positions[3 * 7];
+  positions[offset + 7] = positions[3 * 7 + 1];
+  positions[offset + 8] = positions[3 * 7 + 2];
+  positions[offset + 9] = positions[3 * 3];
+  positions[offset + 10] = positions[3 * 3 + 1];
+  positions[offset + 11] = positions[3 * 3 + 2];
+  if (!drawNearPlane) {
+    positions = positions.subarray(3 * 4);
+  }
+  const attributes = new GeometryAttributes_default({
+    position: new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.DOUBLE,
+      componentsPerAttribute: 3,
+      values: positions
+    })
+  });
+  if (defined_default(vertexFormat.normal) || defined_default(vertexFormat.tangent) || defined_default(vertexFormat.bitangent) || defined_default(vertexFormat.st)) {
+    const normals = defined_default(vertexFormat.normal) ? new Float32Array(3 * 4 * numberOfPlanes) : void 0;
+    const tangents = defined_default(vertexFormat.tangent) ? new Float32Array(3 * 4 * numberOfPlanes) : void 0;
+    const bitangents = defined_default(vertexFormat.bitangent) ? new Float32Array(3 * 4 * numberOfPlanes) : void 0;
+    const st = defined_default(vertexFormat.st) ? new Float32Array(2 * 4 * numberOfPlanes) : void 0;
+    const x = scratchXDirection;
+    const y = scratchYDirection;
+    const z = scratchZDirection;
+    const negativeX = Cartesian3_default.negate(x, scratchNegativeX);
+    const negativeY = Cartesian3_default.negate(y, scratchNegativeY);
+    const negativeZ = Cartesian3_default.negate(z, scratchNegativeZ);
+    offset = 0;
+    if (drawNearPlane) {
+      getAttributes(offset, normals, tangents, bitangents, st, negativeZ, x, y);
+      offset += 3 * 4;
+    }
+    getAttributes(offset, normals, tangents, bitangents, st, z, negativeX, y);
+    offset += 3 * 4;
+    getAttributes(
+      offset,
+      normals,
+      tangents,
+      bitangents,
+      st,
+      negativeX,
+      negativeZ,
+      y
+    );
+    offset += 3 * 4;
+    getAttributes(
+      offset,
+      normals,
+      tangents,
+      bitangents,
+      st,
+      negativeY,
+      negativeZ,
+      negativeX
+    );
+    offset += 3 * 4;
+    getAttributes(offset, normals, tangents, bitangents, st, x, z, y);
+    offset += 3 * 4;
+    getAttributes(offset, normals, tangents, bitangents, st, y, z, negativeX);
+    if (defined_default(normals)) {
+      attributes.normal = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.FLOAT,
+        componentsPerAttribute: 3,
+        values: normals
+      });
+    }
+    if (defined_default(tangents)) {
+      attributes.tangent = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.FLOAT,
+        componentsPerAttribute: 3,
+        values: tangents
+      });
+    }
+    if (defined_default(bitangents)) {
+      attributes.bitangent = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.FLOAT,
+        componentsPerAttribute: 3,
+        values: bitangents
+      });
+    }
+    if (defined_default(st)) {
+      attributes.st = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.FLOAT,
+        componentsPerAttribute: 2,
+        values: st
+      });
+    }
+  }
+  const indices = new Uint16Array(6 * numberOfPlanes);
+  for (let i = 0; i < numberOfPlanes; ++i) {
+    const indexOffset = i * 6;
+    const index = i * 4;
+    indices[indexOffset] = index;
+    indices[indexOffset + 1] = index + 1;
+    indices[indexOffset + 2] = index + 2;
+    indices[indexOffset + 3] = index;
+    indices[indexOffset + 4] = index + 2;
+    indices[indexOffset + 5] = index + 3;
+  }
+  return new Geometry_default({
+    attributes,
+    indices,
+    primitiveType: PrimitiveType_default.TRIANGLES,
+    boundingSphere: BoundingSphere_default.fromVertices(positions)
+  });
+};
+var FrustumGeometry_default = FrustumGeometry;
+
+export {
+  OrthographicFrustum_default,
+  PerspectiveFrustum_default,
+  FrustumGeometry_default
+};

public/assets/cesium/Workers/chunk-7ZZ5LMZY.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  AttributeCompression_default
+} from "./chunk-LJ2JQHJT.js";
+import {
+  EncodedCartesian3_default
+} from "./chunk-NGZJIN5Z.js";
+import {
+  IntersectionTests_default
+} from "./chunk-QQOZO7KO.js";
+import {
+  Plane_default
+} from "./chunk-EDLRS3AW.js";
+import {
+  IndexDatatype_default
+} from "./chunk-C4WPMOKT.js";
+import {
+  GeometryAttribute_default,
+  GeometryType_default,
+  Geometry_default,
+  PrimitiveType_default
+} from "./chunk-JXVLNVXC.js";
+import {
+  BoundingSphere_default,
+  GeographicProjection_default,
+  Intersect_default
+} from "./chunk-KHZNBFOH.js";
+import {
+  Cartesian4_default,
+  Matrix4_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian2_default,
+  Cartesian3_default,
+  Cartographic_default,
+  Matrix3_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import {
+  defaultValue_default
+} from "./chunk-U5HSOKPQ.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/barycentricCoordinates.js
+var scratchCartesian1 = new Cartesian3_default();
+var scratchCartesian2 = new Cartesian3_default();
+var scratchCartesian3 = new Cartesian3_default();
+function barycentricCoordinates(point, p0, p1, p2, result) {
+  Check_default.defined("point", point);
+  Check_default.defined("p0", p0);
+  Check_default.defined("p1", p1);
+  Check_default.defined("p2", p2);
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  let v02;
+  let v12;
+  let v22;
+  let dot00;
+  let dot01;
+  let dot02;
+  let dot11;
+  let dot12;
+  if (!defined_default(p0.z)) {
+    if (Cartesian2_default.equalsEpsilon(point, p0, Math_default.EPSILON14)) {
+      return Cartesian3_default.clone(Cartesian3_default.UNIT_X, result);
+    }
+    if (Cartesian2_default.equalsEpsilon(point, p1, Math_default.EPSILON14)) {
+      return Cartesian3_default.clone(Cartesian3_default.UNIT_Y, result);
+    }
+    if (Cartesian2_default.equalsEpsilon(point, p2, Math_default.EPSILON14)) {
+      return Cartesian3_default.clone(Cartesian3_default.UNIT_Z, result);
+    }
+    v02 = Cartesian2_default.subtract(p1, p0, scratchCartesian1);
+    v12 = Cartesian2_default.subtract(p2, p0, scratchCartesian2);
+    v22 = Cartesian2_default.subtract(point, p0, scratchCartesian3);
+    dot00 = Cartesian2_default.dot(v02, v02);
+    dot01 = Cartesian2_default.dot(v02, v12);
+    dot02 = Cartesian2_default.dot(v02, v22);
+    dot11 = Cartesian2_default.dot(v12, v12);
+    dot12 = Cartesian2_default.dot(v12, v22);
+  } else {
+    if (Cartesian3_default.equalsEpsilon(point, p0, Math_default.EPSILON14)) {
+      return Cartesian3_default.clone(Cartesian3_default.UNIT_X, result);
+    }
+    if (Cartesian3_default.equalsEpsilon(point, p1, Math_default.EPSILON14)) {
+      return Cartesian3_default.clone(Cartesian3_default.UNIT_Y, result);
+    }
+    if (Cartesian3_default.equalsEpsilon(point, p2, Math_default.EPSILON14)) {
+      return Cartesian3_default.clone(Cartesian3_default.UNIT_Z, result);
+    }
+    v02 = Cartesian3_default.subtract(p1, p0, scratchCartesian1);
+    v12 = Cartesian3_default.subtract(p2, p0, scratchCartesian2);
+    v22 = Cartesian3_default.subtract(point, p0, scratchCartesian3);
+    dot00 = Cartesian3_default.dot(v02, v02);
+    dot01 = Cartesian3_default.dot(v02, v12);
+    dot02 = Cartesian3_default.dot(v02, v22);
+    dot11 = Cartesian3_default.dot(v12, v12);
+    dot12 = Cartesian3_default.dot(v12, v22);
+  }
+  result.y = dot11 * dot02 - dot01 * dot12;
+  result.z = dot00 * dot12 - dot01 * dot02;
+  const q = dot00 * dot11 - dot01 * dot01;
+  if (q === 0) {
+    return void 0;
+  }
+  result.y /= q;
+  result.z /= q;
+  result.x = 1 - result.y - result.z;
+  return result;
+}
+var barycentricCoordinates_default = barycentricCoordinates;
+
+// packages/engine/Source/Core/Tipsify.js
+var Tipsify = {};
+Tipsify.calculateACMR = function(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const indices = options.indices;
+  let maximumIndex = options.maximumIndex;
+  const cacheSize = defaultValue_default(options.cacheSize, 24);
+  if (!defined_default(indices)) {
+    throw new DeveloperError_default("indices is required.");
+  }
+  const numIndices = indices.length;
+  if (numIndices < 3 || numIndices % 3 !== 0) {
+    throw new DeveloperError_default("indices length must be a multiple of three.");
+  }
+  if (maximumIndex <= 0) {
+    throw new DeveloperError_default("maximumIndex must be greater than zero.");
+  }
+  if (cacheSize < 3) {
+    throw new DeveloperError_default("cacheSize must be greater than two.");
+  }
+  if (!defined_default(maximumIndex)) {
+    maximumIndex = 0;
+    let currentIndex = 0;
+    let intoIndices = indices[currentIndex];
+    while (currentIndex < numIndices) {
+      if (intoIndices > maximumIndex) {
+        maximumIndex = intoIndices;
+      }
+      ++currentIndex;
+      intoIndices = indices[currentIndex];
+    }
+  }
+  const vertexTimeStamps = [];
+  for (let i = 0; i < maximumIndex + 1; i++) {
+    vertexTimeStamps[i] = 0;
+  }
+  let s = cacheSize + 1;
+  for (let j = 0; j < numIndices; ++j) {
+    if (s - vertexTimeStamps[indices[j]] > cacheSize) {
+      vertexTimeStamps[indices[j]] = s;
+      ++s;
+    }
+  }
+  return (s - cacheSize + 1) / (numIndices / 3);
+};
+Tipsify.tipsify = function(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const indices = options.indices;
+  const maximumIndex = options.maximumIndex;
+  const cacheSize = defaultValue_default(options.cacheSize, 24);
+  let cursor;
+  function skipDeadEnd(vertices2, deadEnd2, indices2, maximumIndexPlusOne2) {
+    while (deadEnd2.length >= 1) {
+      const d = deadEnd2[deadEnd2.length - 1];
+      deadEnd2.splice(deadEnd2.length - 1, 1);
+      if (vertices2[d].numLiveTriangles > 0) {
+        return d;
+      }
+    }
+    while (cursor < maximumIndexPlusOne2) {
+      if (vertices2[cursor].numLiveTriangles > 0) {
+        ++cursor;
+        return cursor - 1;
+      }
+      ++cursor;
+    }
+    return -1;
+  }
+  function getNextVertex(indices2, cacheSize2, oneRing2, vertices2, s2, deadEnd2, maximumIndexPlusOne2) {
+    let n = -1;
+    let p;
+    let m = -1;
+    let itOneRing = 0;
+    while (itOneRing < oneRing2.length) {
+      const index2 = oneRing2[itOneRing];
+      if (vertices2[index2].numLiveTriangles) {
+        p = 0;
+        if (s2 - vertices2[index2].timeStamp + 2 * vertices2[index2].numLiveTriangles <= cacheSize2) {
+          p = s2 - vertices2[index2].timeStamp;
+        }
+        if (p > m || m === -1) {
+          m = p;
+          n = index2;
+        }
+      }
+      ++itOneRing;
+    }
+    if (n === -1) {
+      return skipDeadEnd(vertices2, deadEnd2, indices2, maximumIndexPlusOne2);
+    }
+    return n;
+  }
+  if (!defined_default(indices)) {
+    throw new DeveloperError_default("indices is required.");
+  }
+  const numIndices = indices.length;
+  if (numIndices < 3 || numIndices % 3 !== 0) {
+    throw new DeveloperError_default("indices length must be a multiple of three.");
+  }
+  if (maximumIndex <= 0) {
+    throw new DeveloperError_default("maximumIndex must be greater than zero.");
+  }
+  if (cacheSize < 3) {
+    throw new DeveloperError_default("cacheSize must be greater than two.");
+  }
+  let maximumIndexPlusOne = 0;
+  let currentIndex = 0;
+  let intoIndices = indices[currentIndex];
+  const endIndex = numIndices;
+  if (defined_default(maximumIndex)) {
+    maximumIndexPlusOne = maximumIndex + 1;
+  } else {
+    while (currentIndex < endIndex) {
+      if (intoIndices > maximumIndexPlusOne) {
+        maximumIndexPlusOne = intoIndices;
+      }
+      ++currentIndex;
+      intoIndices = indices[currentIndex];
+    }
+    if (maximumIndexPlusOne === -1) {
+      return 0;
+    }
+    ++maximumIndexPlusOne;
+  }
+  const vertices = [];
+  let i;
+  for (i = 0; i < maximumIndexPlusOne; i++) {
+    vertices[i] = {
+      numLiveTriangles: 0,
+      timeStamp: 0,
+      vertexTriangles: []
+    };
+  }
+  currentIndex = 0;
+  let triangle = 0;
+  while (currentIndex < endIndex) {
+    vertices[indices[currentIndex]].vertexTriangles.push(triangle);
+    ++vertices[indices[currentIndex]].numLiveTriangles;
+    vertices[indices[currentIndex + 1]].vertexTriangles.push(triangle);
+    ++vertices[indices[currentIndex + 1]].numLiveTriangles;
+    vertices[indices[currentIndex + 2]].vertexTriangles.push(triangle);
+    ++vertices[indices[currentIndex + 2]].numLiveTriangles;
+    ++triangle;
+    currentIndex += 3;
+  }
+  let f = 0;
+  let s = cacheSize + 1;
+  cursor = 1;
+  let oneRing = [];
+  const deadEnd = [];
+  let vertex;
+  let intoVertices;
+  let currentOutputIndex = 0;
+  const outputIndices = [];
+  const numTriangles = numIndices / 3;
+  const triangleEmitted = [];
+  for (i = 0; i < numTriangles; i++) {
+    triangleEmitted[i] = false;
+  }
+  let index;
+  let limit;
+  while (f !== -1) {
+    oneRing = [];
+    intoVertices = vertices[f];
+    limit = intoVertices.vertexTriangles.length;
+    for (let k = 0; k < limit; ++k) {
+      triangle = intoVertices.vertexTriangles[k];
+      if (!triangleEmitted[triangle]) {
+        triangleEmitted[triangle] = true;
+        currentIndex = triangle + triangle + triangle;
+        for (let j = 0; j < 3; ++j) {
+          index = indices[currentIndex];
+          oneRing.push(index);
+          deadEnd.push(index);
+          outputIndices[currentOutputIndex] = index;
+          ++currentOutputIndex;
+          vertex = vertices[index];
+          --vertex.numLiveTriangles;
+          if (s - vertex.timeStamp > cacheSize) {
+            vertex.timeStamp = s;
+            ++s;
+          }
+          ++currentIndex;
+        }
+      }
+    }
+    f = getNextVertex(
+      indices,
+      cacheSize,
+      oneRing,
+      vertices,
+      s,
+      deadEnd,
+      maximumIndexPlusOne
+    );
+  }
+  return outputIndices;
+};
+var Tipsify_default = Tipsify;
+
+// packages/engine/Source/Core/GeometryPipeline.js
+var GeometryPipeline = {};
+function addTriangle(lines, index, i0, i1, i2) {
+  lines[index++] = i0;
+  lines[index++] = i1;
+  lines[index++] = i1;
+  lines[index++] = i2;
+  lines[index++] = i2;
+  lines[index] = i0;
+}
+function trianglesToLines(triangles) {
+  const count = triangles.length;
+  const size = count / 3 * 6;
+  const lines = IndexDatatype_default.createTypedArray(count, size);
+  let index = 0;
+  for (let i = 0; i < count; i += 3, index += 6) {
+    addTriangle(lines, index, triangles[i], triangles[i + 1], triangles[i + 2]);
+  }
+  return lines;
+}
+function triangleStripToLines(triangles) {
+  const count = triangles.length;
+  if (count >= 3) {
+    const size = (count - 2) * 6;
+    const lines = IndexDatatype_default.createTypedArray(count, size);
+    addTriangle(lines, 0, triangles[0], triangles[1], triangles[2]);
+    let index = 6;
+    for (let i = 3; i < count; ++i, index += 6) {
+      addTriangle(
+        lines,
+        index,
+        triangles[i - 1],
+        triangles[i],
+        triangles[i - 2]
+      );
+    }
+    return lines;
+  }
+  return new Uint16Array();
+}
+function triangleFanToLines(triangles) {
+  if (triangles.length > 0) {
+    const count = triangles.length - 1;
+    const size = (count - 1) * 6;
+    const lines = IndexDatatype_default.createTypedArray(count, size);
+    const base = triangles[0];
+    let index = 0;
+    for (let i = 1; i < count; ++i, index += 6) {
+      addTriangle(lines, index, base, triangles[i], triangles[i + 1]);
+    }
+    return lines;
+  }
+  return new Uint16Array();
+}
+GeometryPipeline.toWireframe = function(geometry) {
+  if (!defined_default(geometry)) {
+    throw new DeveloperError_default("geometry is required.");
+  }
+  const indices = geometry.indices;
+  if (defined_default(indices)) {
+    switch (geometry.primitiveType) {
+      case PrimitiveType_default.TRIANGLES:
+        geometry.indices = trianglesToLines(indices);
+        break;
+      case PrimitiveType_default.TRIANGLE_STRIP:
+        geometry.indices = triangleStripToLines(indices);
+        break;
+      case PrimitiveType_default.TRIANGLE_FAN:
+        geometry.indices = triangleFanToLines(indices);
+        break;
+      //>>includeStart('debug', pragmas.debug);
+      default:
+        throw new DeveloperError_default(
+          "geometry.primitiveType must be TRIANGLES, TRIANGLE_STRIP, or TRIANGLE_FAN."
+        );
+    }
+    geometry.primitiveType = PrimitiveType_default.LINES;
+  }
+  return geometry;
+};
+GeometryPipeline.createLineSegmentsForVectors = function(geometry, attributeName, length) {
+  attributeName = defaultValue_default(attributeName, "normal");
+  if (!defined_default(geometry)) {
+    throw new DeveloperError_default("geometry is required.");
+  }
+  if (!defined_default(geometry.attributes.position)) {
+    throw new DeveloperError_default("geometry.attributes.position is required.");
+  }
+  if (!defined_default(geometry.attributes[attributeName])) {
+    throw new DeveloperError_default(
+      `geometry.attributes must have an attribute with the same name as the attributeName parameter, ${attributeName}.`
+    );
+  }
+  length = defaultValue_default(length, 1e4);
+  const positions = geometry.attributes.position.values;
+  const vectors = geometry.attributes[attributeName].values;
+  const positionsLength = positions.length;
+  const newPositions = new Float64Array(2 * positionsLength);
+  let j = 0;
+  for (let i = 0; i < positionsLength; i += 3) {
+    newPositions[j++] = positions[i];
+    newPositions[j++] = positions[i + 1];
+    newPositions[j++] = positions[i + 2];
+    newPositions[j++] = positions[i] + vectors[i] * length;
+    newPositions[j++] = positions[i + 1] + vectors[i + 1] * length;
+    newPositions[j++] = positions[i + 2] + vectors[i + 2] * length;
+  }
+  let newBoundingSphere;
+  const bs = geometry.boundingSphere;
+  if (defined_default(bs)) {
+    newBoundingSphere = new BoundingSphere_default(bs.center, bs.radius + length);
+  }
+  return new Geometry_default({
+    attributes: {
+      position: new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.DOUBLE,
+        componentsPerAttribute: 3,
+        values: newPositions
+      })
+    },
+    primitiveType: PrimitiveType_default.LINES,
+    boundingSphere: newBoundingSphere
+  });
+};
+GeometryPipeline.createAttributeLocations = function(geometry) {
+  if (!defined_default(geometry)) {
+    throw new DeveloperError_default("geometry is required.");
+  }
+  const semantics = [
+    "position",
+    "positionHigh",
+    "positionLow",
+    // From VertexFormat.position - after 2D projection and high-precision encoding
+    "position3DHigh",
+    "position3DLow",
+    "position2DHigh",
+    "position2DLow",
+    // From Primitive
+    "pickColor",
+    // From VertexFormat
+    "normal",
+    "st",
+    "tangent",
+    "bitangent",
+    // For shadow volumes
+    "extrudeDirection",
+    // From compressing texture coordinates and normals
+    "compressedAttributes"
+  ];
+  const attributes = geometry.attributes;
+  const indices = {};
+  let j = 0;
+  let i;
+  const len = semantics.length;
+  for (i = 0; i < len; ++i) {
+    const semantic = semantics[i];
+    if (defined_default(attributes[semantic])) {
+      indices[semantic] = j++;
+    }
+  }
+  for (const name in attributes) {
+    if (attributes.hasOwnProperty(name) && !defined_default(indices[name])) {
+      indices[name] = j++;
+    }
+  }
+  return indices;
+};
+GeometryPipeline.reorderForPreVertexCache = function(geometry) {
+  if (!defined_default(geometry)) {
+    throw new DeveloperError_default("geometry is required.");
+  }
+  const numVertices = Geometry_default.computeNumberOfVertices(geometry);
+  const indices = geometry.indices;
+  if (defined_default(indices)) {
+    const indexCrossReferenceOldToNew = new Int32Array(numVertices);
+    for (let i = 0; i < numVertices; i++) {
+      indexCrossReferenceOldToNew[i] = -1;
+    }
+    const indicesIn = indices;
+    const numIndices = indicesIn.length;
+    const indicesOut = IndexDatatype_default.createTypedArray(numVertices, numIndices);
+    let intoIndicesIn = 0;
+    let intoIndicesOut = 0;
+    let nextIndex = 0;
+    let tempIndex;
+    while (intoIndicesIn < numIndices) {
+      tempIndex = indexCrossReferenceOldToNew[indicesIn[intoIndicesIn]];
+      if (tempIndex !== -1) {
+        indicesOut[intoIndicesOut] = tempIndex;
+      } else {
+        tempIndex = indicesIn[intoIndicesIn];
+        indexCrossReferenceOldToNew[tempIndex] = nextIndex;
+        indicesOut[intoIndicesOut] = nextIndex;
+        ++nextIndex;
+      }
+      ++intoIndicesIn;
+      ++intoIndicesOut;
+    }
+    geometry.indices = indicesOut;
+    const attributes = geometry.attributes;
+    for (const property in attributes) {
+      if (attributes.hasOwnProperty(property) && defined_default(attributes[property]) && defined_default(attributes[property].values)) {
+        const attribute = attributes[property];
+        const elementsIn = attribute.values;
+        let intoElementsIn = 0;
+        const numComponents = attribute.componentsPerAttribute;
+        const elementsOut = ComponentDatatype_default.createTypedArray(
+          attribute.componentDatatype,
+          nextIndex * numComponents
+        );
+        while (intoElementsIn < numVertices) {
+          const temp = indexCrossReferenceOldToNew[intoElementsIn];
+          if (temp !== -1) {
+            for (let j = 0; j < numComponents; j++) {
+              elementsOut[numComponents * temp + j] = elementsIn[numComponents * intoElementsIn + j];
+            }
+          }
+          ++intoElementsIn;
+        }
+        attribute.values = elementsOut;
+      }
+    }
+  }
+  return geometry;
+};
+GeometryPipeline.reorderForPostVertexCache = function(geometry, cacheCapacity) {
+  if (!defined_default(geometry)) {
+    throw new DeveloperError_default("geometry is required.");
+  }
+  const indices = geometry.indices;
+  if (geometry.primitiveType === PrimitiveType_default.TRIANGLES && defined_default(indices)) {
+    const numIndices = indices.length;
+    let maximumIndex = 0;
+    for (let j = 0; j < numIndices; j++) {
+      if (indices[j] > maximumIndex) {
+        maximumIndex = indices[j];
+      }
+    }
+    geometry.indices = Tipsify_default.tipsify({
+      indices,
+      maximumIndex,
+      cacheSize: cacheCapacity
+    });
+  }
+  return geometry;
+};
+function copyAttributesDescriptions(attributes) {
+  const newAttributes = {};
+  for (const attribute in attributes) {
+    if (attributes.hasOwnProperty(attribute) && defined_default(attributes[attribute]) && defined_default(attributes[attribute].values)) {
+      const attr = attributes[attribute];
+      newAttributes[attribute] = new GeometryAttribute_default({
+        componentDatatype: attr.componentDatatype,
+        componentsPerAttribute: attr.componentsPerAttribute,
+        normalize: attr.normalize,
+        values: []
+      });
+    }
+  }
+  return newAttributes;
+}
+function copyVertex(destinationAttributes, sourceAttributes, index) {
+  for (const attribute in sourceAttributes) {
+    if (sourceAttributes.hasOwnProperty(attribute) && defined_default(sourceAttributes[attribute]) && defined_default(sourceAttributes[attribute].values)) {
+      const attr = sourceAttributes[attribute];
+      for (let k = 0; k < attr.componentsPerAttribute; ++k) {
+        destinationAttributes[attribute].values.push(
+          attr.values[index * attr.componentsPerAttribute + k]
+        );
+      }
+    }
+  }
+}
+GeometryPipeline.fitToUnsignedShortIndices = function(geometry) {
+  if (!defined_default(geometry)) {
+    throw new DeveloperError_default("geometry is required.");
+  }
+  if (defined_default(geometry.indices) && geometry.primitiveType !== PrimitiveType_default.TRIANGLES && geometry.primitiveType !== PrimitiveType_default.LINES && geometry.primitiveType !== PrimitiveType_default.POINTS) {
+    throw new DeveloperError_default(
+      "geometry.primitiveType must equal to PrimitiveType.TRIANGLES, PrimitiveType.LINES, or PrimitiveType.POINTS."
+    );
+  }
+  const geometries = [];
+  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
+  if (defined_default(geometry.indices) && numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
+    let oldToNewIndex = [];
+    let newIndices = [];
+    let currentIndex = 0;
+    let newAttributes = copyAttributesDescriptions(geometry.attributes);
+    const originalIndices = geometry.indices;
+    const numberOfIndices = originalIndices.length;
+    let indicesPerPrimitive;
+    if (geometry.primitiveType === PrimitiveType_default.TRIANGLES) {
+      indicesPerPrimitive = 3;
+    } else if (geometry.primitiveType === PrimitiveType_default.LINES) {
+      indicesPerPrimitive = 2;
+    } else if (geometry.primitiveType === PrimitiveType_default.POINTS) {
+      indicesPerPrimitive = 1;
+    }
+    for (let j = 0; j < numberOfIndices; j += indicesPerPrimitive) {
+      for (let k = 0; k < indicesPerPrimitive; ++k) {
+        const x = originalIndices[j + k];
+        let i = oldToNewIndex[x];
+        if (!defined_default(i)) {
+          i = currentIndex++;
+          oldToNewIndex[x] = i;
+          copyVertex(newAttributes, geometry.attributes, x);
+        }
+        newIndices.push(i);
+      }
+      if (currentIndex + indicesPerPrimitive >= Math_default.SIXTY_FOUR_KILOBYTES) {
+        geometries.push(
+          new Geometry_default({
+            attributes: newAttributes,
+            indices: newIndices,
+            primitiveType: geometry.primitiveType,
+            boundingSphere: geometry.boundingSphere,
+            boundingSphereCV: geometry.boundingSphereCV
+          })
+        );
+        oldToNewIndex = [];
+        newIndices = [];
+        currentIndex = 0;
+        newAttributes = copyAttributesDescriptions(geometry.attributes);
+      }
+    }
+    if (newIndices.length !== 0) {
+      geometries.push(
+        new Geometry_default({
+          attributes: newAttributes,
+          indices: newIndices,
+          primitiveType: geometry.primitiveType,
+          boundingSphere: geometry.boundingSphere,
+          boundingSphereCV: geometry.boundingSphereCV
+        })
+      );
+    }
+  } else {
+    geometries.push(geometry);
+  }
+  return geometries;
+};
+var scratchProjectTo2DCartesian3 = new Cartesian3_default();
+var scratchProjectTo2DCartographic = new Cartographic_default();
+GeometryPipeline.projectTo2D = function(geometry, attributeName, attributeName3D, attributeName2D, projection) {
+  if (!defined_default(geometry)) {
+    throw new DeveloperError_default("geometry is required.");
+  }
+  if (!defined_default(attributeName)) {
+    throw new DeveloperError_default("attributeName is required.");
+  }
+  if (!defined_default(attributeName3D)) {
+    throw new DeveloperError_default("attributeName3D is required.");
+  }
+  if (!defined_default(attributeName2D)) {
+    throw new DeveloperError_default("attributeName2D is required.");
+  }
+  if (!defined_default(geometry.attributes[attributeName])) {
+    throw new DeveloperError_default(
+      `geometry must have attribute matching the attributeName argument: ${attributeName}.`
+    );
+  }
+  if (geometry.attributes[attributeName].componentDatatype !== ComponentDatatype_default.DOUBLE) {
+    throw new DeveloperError_default(
+      "The attribute componentDatatype must be ComponentDatatype.DOUBLE."
+    );
+  }
+  const attribute = geometry.attributes[attributeName];
+  projection = defined_default(projection) ? projection : new GeographicProjection_default();
+  const ellipsoid = projection.ellipsoid;
+  const values3D = attribute.values;
+  const projectedValues = new Float64Array(values3D.length);
+  let index = 0;
+  for (let i = 0; i < values3D.length; i += 3) {
+    const value = Cartesian3_default.fromArray(
+      values3D,
+      i,
+      scratchProjectTo2DCartesian3
+    );
+    const lonLat = ellipsoid.cartesianToCartographic(
+      value,
+      scratchProjectTo2DCartographic
+    );
+    if (!defined_default(lonLat)) {
+      throw new DeveloperError_default(
+        `Could not project point (${value.x}, ${value.y}, ${value.z}) to 2D.`
+      );
+    }
+    const projectedLonLat = projection.project(
+      lonLat,
+      scratchProjectTo2DCartesian3
+    );
+    projectedValues[index++] = projectedLonLat.x;
+    projectedValues[index++] = projectedLonLat.y;
+    projectedValues[index++] = projectedLonLat.z;
+  }
+  geometry.attributes[attributeName3D] = attribute;
+  geometry.attributes[attributeName2D] = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.DOUBLE,
+    componentsPerAttribute: 3,
+    values: projectedValues
+  });
+  delete geometry.attributes[attributeName];
+  return geometry;
+};
+var encodedResult = {
+  high: 0,
+  low: 0
+};
+GeometryPipeline.encodeAttribute = function(geometry, attributeName, attributeHighName, attributeLowName) {
+  if (!defined_default(geometry)) {
+    throw new DeveloperError_default("geometry is required.");
+  }
+  if (!defined_default(attributeName)) {
+    throw new DeveloperError_default("attributeName is required.");
+  }
+  if (!defined_default(attributeHighName)) {
+    throw new DeveloperError_default("attributeHighName is required.");
+  }
+  if (!defined_default(attributeLowName)) {
+    throw new DeveloperError_default("attributeLowName is required.");
+  }
+  if (!defined_default(geometry.attributes[attributeName])) {
+    throw new DeveloperError_default(
+      `geometry must have attribute matching the attributeName argument: ${attributeName}.`
+    );
+  }
+  if (geometry.attributes[attributeName].componentDatatype !== ComponentDatatype_default.DOUBLE) {
+    throw new DeveloperError_default(
+      "The attribute componentDatatype must be ComponentDatatype.DOUBLE."
+    );
+  }
+  const attribute = geometry.attributes[attributeName];
+  const values = attribute.values;
+  const length = values.length;
+  const highValues = new Float32Array(length);
+  const lowValues = new Float32Array(length);
+  for (let i = 0; i < length; ++i) {
+    EncodedCartesian3_default.encode(values[i], encodedResult);
+    highValues[i] = encodedResult.high;
+    lowValues[i] = encodedResult.low;
+  }
+  const componentsPerAttribute = attribute.componentsPerAttribute;
+  geometry.attributes[attributeHighName] = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.FLOAT,
+    componentsPerAttribute,
+    values: highValues
+  });
+  geometry.attributes[attributeLowName] = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.FLOAT,
+    componentsPerAttribute,
+    values: lowValues
+  });
+  delete geometry.attributes[attributeName];
+  return geometry;
+};
+var scratchCartesian32 = new Cartesian3_default();
+function transformPoint(matrix, attribute) {
+  if (defined_default(attribute)) {
+    const values = attribute.values;
+    const length = values.length;
+    for (let i = 0; i < length; i += 3) {
+      Cartesian3_default.unpack(values, i, scratchCartesian32);
+      Matrix4_default.multiplyByPoint(matrix, scratchCartesian32, scratchCartesian32);
+      Cartesian3_default.pack(scratchCartesian32, values, i);
+    }
+  }
+}
+function transformVector(matrix, attribute) {
+  if (defined_default(attribute)) {
+    const values = attribute.values;
+    const length = values.length;
+    for (let i = 0; i < length; i += 3) {
+      Cartesian3_default.unpack(values, i, scratchCartesian32);
+      Matrix3_default.multiplyByVector(matrix, scratchCartesian32, scratchCartesian32);
+      scratchCartesian32 = Cartesian3_default.normalize(
+        scratchCartesian32,
+        scratchCartesian32
+      );
+      Cartesian3_default.pack(scratchCartesian32, values, i);
+    }
+  }
+}
+var inverseTranspose = new Matrix4_default();
+var normalMatrix = new Matrix3_default();
+GeometryPipeline.transformToWorldCoordinates = function(instance) {
+  if (!defined_default(instance)) {
+    throw new DeveloperError_default("instance is required.");
+  }
+  const modelMatrix = instance.modelMatrix;
+  if (Matrix4_default.equals(modelMatrix, Matrix4_default.IDENTITY)) {
+    return instance;
+  }
+  const attributes = instance.geometry.attributes;
+  transformPoint(modelMatrix, attributes.position);
+  transformPoint(modelMatrix, attributes.prevPosition);
+  transformPoint(modelMatrix, attributes.nextPosition);
+  if (defined_default(attributes.normal) || defined_default(attributes.tangent) || defined_default(attributes.bitangent)) {
+    Matrix4_default.inverse(modelMatrix, inverseTranspose);
+    Matrix4_default.transpose(inverseTranspose, inverseTranspose);
+    Matrix4_default.getMatrix3(inverseTranspose, normalMatrix);
+    transformVector(normalMatrix, attributes.normal);
+    transformVector(normalMatrix, attributes.tangent);
+    transformVector(normalMatrix, attributes.bitangent);
+  }
+  const boundingSphere = instance.geometry.boundingSphere;
+  if (defined_default(boundingSphere)) {
+    instance.geometry.boundingSphere = BoundingSphere_default.transform(
+      boundingSphere,
+      modelMatrix,
+      boundingSphere
+    );
+  }
+  instance.modelMatrix = Matrix4_default.clone(Matrix4_default.IDENTITY);
+  return instance;
+};
+function findAttributesInAllGeometries(instances, propertyName) {
+  const length = instances.length;
+  const attributesInAllGeometries = {};
+  const attributes0 = instances[0][propertyName].attributes;
+  let name;
+  for (name in attributes0) {
+    if (attributes0.hasOwnProperty(name) && defined_default(attributes0[name]) && defined_default(attributes0[name].values)) {
+      const attribute = attributes0[name];
+      let numberOfComponents = attribute.values.length;
+      let inAllGeometries = true;
+      for (let i = 1; i < length; ++i) {
+        const otherAttribute = instances[i][propertyName].attributes[name];
+        if (!defined_default(otherAttribute) || attribute.componentDatatype !== otherAttribute.componentDatatype || attribute.componentsPerAttribute !== otherAttribute.componentsPerAttribute || attribute.normalize !== otherAttribute.normalize) {
+          inAllGeometries = false;
+          break;
+        }
+        numberOfComponents += otherAttribute.values.length;
+      }
+      if (inAllGeometries) {
+        attributesInAllGeometries[name] = new GeometryAttribute_default({
+          componentDatatype: attribute.componentDatatype,
+          componentsPerAttribute: attribute.componentsPerAttribute,
+          normalize: attribute.normalize,
+          values: ComponentDatatype_default.createTypedArray(
+            attribute.componentDatatype,
+            numberOfComponents
+          )
+        });
+      }
+    }
+  }
+  return attributesInAllGeometries;
+}
+var tempScratch = new Cartesian3_default();
+function combineGeometries(instances, propertyName) {
+  const length = instances.length;
+  let name;
+  let i;
+  let j;
+  let k;
+  const m = instances[0].modelMatrix;
+  const haveIndices = defined_default(instances[0][propertyName].indices);
+  const primitiveType = instances[0][propertyName].primitiveType;
+  for (i = 1; i < length; ++i) {
+    if (!Matrix4_default.equals(instances[i].modelMatrix, m)) {
+      throw new DeveloperError_default("All instances must have the same modelMatrix.");
+    }
+    if (defined_default(instances[i][propertyName].indices) !== haveIndices) {
+      throw new DeveloperError_default(
+        "All instance geometries must have an indices or not have one."
+      );
+    }
+    if (instances[i][propertyName].primitiveType !== primitiveType) {
+      throw new DeveloperError_default(
+        "All instance geometries must have the same primitiveType."
+      );
+    }
+  }
+  const attributes = findAttributesInAllGeometries(instances, propertyName);
+  let values;
+  let sourceValues;
+  let sourceValuesLength;
+  for (name in attributes) {
+    if (attributes.hasOwnProperty(name)) {
+      values = attributes[name].values;
+      k = 0;
+      for (i = 0; i < length; ++i) {
+        sourceValues = instances[i][propertyName].attributes[name].values;
+        sourceValuesLength = sourceValues.length;
+        for (j = 0; j < sourceValuesLength; ++j) {
+          values[k++] = sourceValues[j];
+        }
+      }
+    }
+  }
+  let indices;
+  if (haveIndices) {
+    let numberOfIndices = 0;
+    for (i = 0; i < length; ++i) {
+      numberOfIndices += instances[i][propertyName].indices.length;
+    }
+    const numberOfVertices = Geometry_default.computeNumberOfVertices(
+      new Geometry_default({
+        attributes,
+        primitiveType: PrimitiveType_default.POINTS
+      })
+    );
+    const destIndices = IndexDatatype_default.createTypedArray(
+      numberOfVertices,
+      numberOfIndices
+    );
+    let destOffset = 0;
+    let offset = 0;
+    for (i = 0; i < length; ++i) {
+      const sourceIndices = instances[i][propertyName].indices;
+      const sourceIndicesLen = sourceIndices.length;
+      for (k = 0; k < sourceIndicesLen; ++k) {
+        destIndices[destOffset++] = offset + sourceIndices[k];
+      }
+      offset += Geometry_default.computeNumberOfVertices(instances[i][propertyName]);
+    }
+    indices = destIndices;
+  }
+  let center = new Cartesian3_default();
+  let radius = 0;
+  let bs;
+  for (i = 0; i < length; ++i) {
+    bs = instances[i][propertyName].boundingSphere;
+    if (!defined_default(bs)) {
+      center = void 0;
+      break;
+    }
+    Cartesian3_default.add(bs.center, center, center);
+  }
+  if (defined_default(center)) {
+    Cartesian3_default.divideByScalar(center, length, center);
+    for (i = 0; i < length; ++i) {
+      bs = instances[i][propertyName].boundingSphere;
+      const tempRadius = Cartesian3_default.magnitude(
+        Cartesian3_default.subtract(bs.center, center, tempScratch)
+      ) + bs.radius;
+      if (tempRadius > radius) {
+        radius = tempRadius;
+      }
+    }
+  }
+  return new Geometry_default({
+    attributes,
+    indices,
+    primitiveType,
+    boundingSphere: defined_default(center) ? new BoundingSphere_default(center, radius) : void 0
+  });
+}
+GeometryPipeline.combineInstances = function(instances) {
+  if (!defined_default(instances) || instances.length < 1) {
+    throw new DeveloperError_default(
+      "instances is required and must have length greater than zero."
+    );
+  }
+  const instanceGeometry = [];
+  const instanceSplitGeometry = [];
+  const length = instances.length;
+  for (let i = 0; i < length; ++i) {
+    const instance = instances[i];
+    if (defined_default(instance.geometry)) {
+      instanceGeometry.push(instance);
+    } else if (defined_default(instance.westHemisphereGeometry) && defined_default(instance.eastHemisphereGeometry)) {
+      instanceSplitGeometry.push(instance);
+    }
+  }
+  const geometries = [];
+  if (instanceGeometry.length > 0) {
+    geometries.push(combineGeometries(instanceGeometry, "geometry"));
+  }
+  if (instanceSplitGeometry.length > 0) {
+    geometries.push(
+      combineGeometries(instanceSplitGeometry, "westHemisphereGeometry")
+    );
+    geometries.push(
+      combineGeometries(instanceSplitGeometry, "eastHemisphereGeometry")
+    );
+  }
+  return geometries;
+};
+var normal = new Cartesian3_default();
+var v0 = new Cartesian3_default();
+var v1 = new Cartesian3_default();
+var v2 = new Cartesian3_default();
+GeometryPipeline.computeNormal = function(geometry) {
+  if (!defined_default(geometry)) {
+    throw new DeveloperError_default("geometry is required.");
+  }
+  if (!defined_default(geometry.attributes.position) || !defined_default(geometry.attributes.position.values)) {
+    throw new DeveloperError_default(
+      "geometry.attributes.position.values is required."
+    );
+  }
+  if (!defined_default(geometry.indices)) {
+    throw new DeveloperError_default("geometry.indices is required.");
+  }
+  if (geometry.indices.length < 2 || geometry.indices.length % 3 !== 0) {
+    throw new DeveloperError_default(
+      "geometry.indices length must be greater than 0 and be a multiple of 3."
+    );
+  }
+  if (geometry.primitiveType !== PrimitiveType_default.TRIANGLES) {
+    throw new DeveloperError_default(
+      "geometry.primitiveType must be PrimitiveType.TRIANGLES."
+    );
+  }
+  const indices = geometry.indices;
+  const attributes = geometry.attributes;
+  const vertices = attributes.position.values;
+  const numVertices = attributes.position.values.length / 3;
+  const numIndices = indices.length;
+  const normalsPerVertex = new Array(numVertices);
+  const normalsPerTriangle = new Array(numIndices / 3);
+  const normalIndices = new Array(numIndices);
+  let i;
+  for (i = 0; i < numVertices; i++) {
+    normalsPerVertex[i] = {
+      indexOffset: 0,
+      count: 0,
+      currentCount: 0
+    };
+  }
+  let j = 0;
+  for (i = 0; i < numIndices; i += 3) {
+    const i0 = indices[i];
+    const i1 = indices[i + 1];
+    const i2 = indices[i + 2];
+    const i03 = i0 * 3;
+    const i13 = i1 * 3;
+    const i23 = i2 * 3;
+    v0.x = vertices[i03];
+    v0.y = vertices[i03 + 1];
+    v0.z = vertices[i03 + 2];
+    v1.x = vertices[i13];
+    v1.y = vertices[i13 + 1];
+    v1.z = vertices[i13 + 2];
+    v2.x = vertices[i23];
+    v2.y = vertices[i23 + 1];
+    v2.z = vertices[i23 + 2];
+    normalsPerVertex[i0].count++;
+    normalsPerVertex[i1].count++;
+    normalsPerVertex[i2].count++;
+    Cartesian3_default.subtract(v1, v0, v1);
+    Cartesian3_default.subtract(v2, v0, v2);
+    normalsPerTriangle[j] = Cartesian3_default.cross(v1, v2, new Cartesian3_default());
+    j++;
+  }
+  let indexOffset = 0;
+  for (i = 0; i < numVertices; i++) {
+    normalsPerVertex[i].indexOffset += indexOffset;
+    indexOffset += normalsPerVertex[i].count;
+  }
+  j = 0;
+  let vertexNormalData;
+  for (i = 0; i < numIndices; i += 3) {
+    vertexNormalData = normalsPerVertex[indices[i]];
+    let index = vertexNormalData.indexOffset + vertexNormalData.currentCount;
+    normalIndices[index] = j;
+    vertexNormalData.currentCount++;
+    vertexNormalData = normalsPerVertex[indices[i + 1]];
+    index = vertexNormalData.indexOffset + vertexNormalData.currentCount;
+    normalIndices[index] = j;
+    vertexNormalData.currentCount++;
+    vertexNormalData = normalsPerVertex[indices[i + 2]];
+    index = vertexNormalData.indexOffset + vertexNormalData.currentCount;
+    normalIndices[index] = j;
+    vertexNormalData.currentCount++;
+    j++;
+  }
+  const normalValues = new Float32Array(numVertices * 3);
+  for (i = 0; i < numVertices; i++) {
+    const i3 = i * 3;
+    vertexNormalData = normalsPerVertex[i];
+    Cartesian3_default.clone(Cartesian3_default.ZERO, normal);
+    if (vertexNormalData.count > 0) {
+      for (j = 0; j < vertexNormalData.count; j++) {
+        Cartesian3_default.add(
+          normal,
+          normalsPerTriangle[normalIndices[vertexNormalData.indexOffset + j]],
+          normal
+        );
+      }
+      if (Cartesian3_default.equalsEpsilon(Cartesian3_default.ZERO, normal, Math_default.EPSILON10)) {
+        Cartesian3_default.clone(
+          normalsPerTriangle[normalIndices[vertexNormalData.indexOffset]],
+          normal
+        );
+      }
+    }
+    if (Cartesian3_default.equalsEpsilon(Cartesian3_default.ZERO, normal, Math_default.EPSILON10)) {
+      normal.z = 1;
+    }
+    Cartesian3_default.normalize(normal, normal);
+    normalValues[i3] = normal.x;
+    normalValues[i3 + 1] = normal.y;
+    normalValues[i3 + 2] = normal.z;
+  }
+  geometry.attributes.normal = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.FLOAT,
+    componentsPerAttribute: 3,
+    values: normalValues
+  });
+  return geometry;
+};
+var normalScratch = new Cartesian3_default();
+var normalScale = new Cartesian3_default();
+var tScratch = new Cartesian3_default();
+GeometryPipeline.computeTangentAndBitangent = function(geometry) {
+  if (!defined_default(geometry)) {
+    throw new DeveloperError_default("geometry is required.");
+  }
+  const attributes = geometry.attributes;
+  const indices = geometry.indices;
+  if (!defined_default(attributes.position) || !defined_default(attributes.position.values)) {
+    throw new DeveloperError_default(
+      "geometry.attributes.position.values is required."
+    );
+  }
+  if (!defined_default(attributes.normal) || !defined_default(attributes.normal.values)) {
+    throw new DeveloperError_default("geometry.attributes.normal.values is required.");
+  }
+  if (!defined_default(attributes.st) || !defined_default(attributes.st.values)) {
+    throw new DeveloperError_default("geometry.attributes.st.values is required.");
+  }
+  if (!defined_default(indices)) {
+    throw new DeveloperError_default("geometry.indices is required.");
+  }
+  if (indices.length < 2 || indices.length % 3 !== 0) {
+    throw new DeveloperError_default(
+      "geometry.indices length must be greater than 0 and be a multiple of 3."
+    );
+  }
+  if (geometry.primitiveType !== PrimitiveType_default.TRIANGLES) {
+    throw new DeveloperError_default(
+      "geometry.primitiveType must be PrimitiveType.TRIANGLES."
+    );
+  }
+  const vertices = geometry.attributes.position.values;
+  const normals = geometry.attributes.normal.values;
+  const st = geometry.attributes.st.values;
+  const numVertices = geometry.attributes.position.values.length / 3;
+  const numIndices = indices.length;
+  const tan1 = new Array(numVertices * 3);
+  let i;
+  for (i = 0; i < tan1.length; i++) {
+    tan1[i] = 0;
+  }
+  let i03;
+  let i13;
+  let i23;
+  for (i = 0; i < numIndices; i += 3) {
+    const i0 = indices[i];
+    const i1 = indices[i + 1];
+    const i2 = indices[i + 2];
+    i03 = i0 * 3;
+    i13 = i1 * 3;
+    i23 = i2 * 3;
+    const i02 = i0 * 2;
+    const i12 = i1 * 2;
+    const i22 = i2 * 2;
+    const ux = vertices[i03];
+    const uy = vertices[i03 + 1];
+    const uz = vertices[i03 + 2];
+    const wx = st[i02];
+    const wy = st[i02 + 1];
+    const t1 = st[i12 + 1] - wy;
+    const t2 = st[i22 + 1] - wy;
+    const r = 1 / ((st[i12] - wx) * t2 - (st[i22] - wx) * t1);
+    const sdirx = (t2 * (vertices[i13] - ux) - t1 * (vertices[i23] - ux)) * r;
+    const sdiry = (t2 * (vertices[i13 + 1] - uy) - t1 * (vertices[i23 + 1] - uy)) * r;
+    const sdirz = (t2 * (vertices[i13 + 2] - uz) - t1 * (vertices[i23 + 2] - uz)) * r;
+    tan1[i03] += sdirx;
+    tan1[i03 + 1] += sdiry;
+    tan1[i03 + 2] += sdirz;
+    tan1[i13] += sdirx;
+    tan1[i13 + 1] += sdiry;
+    tan1[i13 + 2] += sdirz;
+    tan1[i23] += sdirx;
+    tan1[i23 + 1] += sdiry;
+    tan1[i23 + 2] += sdirz;
+  }
+  const tangentValues = new Float32Array(numVertices * 3);
+  const bitangentValues = new Float32Array(numVertices * 3);
+  for (i = 0; i < numVertices; i++) {
+    i03 = i * 3;
+    i13 = i03 + 1;
+    i23 = i03 + 2;
+    const n = Cartesian3_default.fromArray(normals, i03, normalScratch);
+    const t = Cartesian3_default.fromArray(tan1, i03, tScratch);
+    const scalar = Cartesian3_default.dot(n, t);
+    Cartesian3_default.multiplyByScalar(n, scalar, normalScale);
+    Cartesian3_default.normalize(Cartesian3_default.subtract(t, normalScale, t), t);
+    tangentValues[i03] = t.x;
+    tangentValues[i13] = t.y;
+    tangentValues[i23] = t.z;
+    Cartesian3_default.normalize(Cartesian3_default.cross(n, t, t), t);
+    bitangentValues[i03] = t.x;
+    bitangentValues[i13] = t.y;
+    bitangentValues[i23] = t.z;
+  }
+  geometry.attributes.tangent = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.FLOAT,
+    componentsPerAttribute: 3,
+    values: tangentValues
+  });
+  geometry.attributes.bitangent = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.FLOAT,
+    componentsPerAttribute: 3,
+    values: bitangentValues
+  });
+  return geometry;
+};
+var scratchCartesian22 = new Cartesian2_default();
+var toEncode1 = new Cartesian3_default();
+var toEncode2 = new Cartesian3_default();
+var toEncode3 = new Cartesian3_default();
+var encodeResult2 = new Cartesian2_default();
+GeometryPipeline.compressVertices = function(geometry) {
+  if (!defined_default(geometry)) {
+    throw new DeveloperError_default("geometry is required.");
+  }
+  const extrudeAttribute = geometry.attributes.extrudeDirection;
+  let i;
+  let numVertices;
+  if (defined_default(extrudeAttribute)) {
+    const extrudeDirections = extrudeAttribute.values;
+    numVertices = extrudeDirections.length / 3;
+    const compressedDirections = new Float32Array(numVertices * 2);
+    let i2 = 0;
+    for (i = 0; i < numVertices; ++i) {
+      Cartesian3_default.fromArray(extrudeDirections, i * 3, toEncode1);
+      if (Cartesian3_default.equals(toEncode1, Cartesian3_default.ZERO)) {
+        i2 += 2;
+        continue;
+      }
+      encodeResult2 = AttributeCompression_default.octEncodeInRange(
+        toEncode1,
+        65535,
+        encodeResult2
+      );
+      compressedDirections[i2++] = encodeResult2.x;
+      compressedDirections[i2++] = encodeResult2.y;
+    }
+    geometry.attributes.compressedAttributes = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 2,
+      values: compressedDirections
+    });
+    delete geometry.attributes.extrudeDirection;
+    return geometry;
+  }
+  const normalAttribute = geometry.attributes.normal;
+  const stAttribute = geometry.attributes.st;
+  const hasNormal = defined_default(normalAttribute);
+  const hasSt = defined_default(stAttribute);
+  if (!hasNormal && !hasSt) {
+    return geometry;
+  }
+  const tangentAttribute = geometry.attributes.tangent;
+  const bitangentAttribute = geometry.attributes.bitangent;
+  const hasTangent = defined_default(tangentAttribute);
+  const hasBitangent = defined_default(bitangentAttribute);
+  let normals;
+  let st;
+  let tangents;
+  let bitangents;
+  if (hasNormal) {
+    normals = normalAttribute.values;
+  }
+  if (hasSt) {
+    st = stAttribute.values;
+  }
+  if (hasTangent) {
+    tangents = tangentAttribute.values;
+  }
+  if (hasBitangent) {
+    bitangents = bitangentAttribute.values;
+  }
+  const length = hasNormal ? normals.length : st.length;
+  const numComponents = hasNormal ? 3 : 2;
+  numVertices = length / numComponents;
+  let compressedLength = numVertices;
+  let numCompressedComponents = hasSt && hasNormal ? 2 : 1;
+  numCompressedComponents += hasTangent || hasBitangent ? 1 : 0;
+  compressedLength *= numCompressedComponents;
+  const compressedAttributes = new Float32Array(compressedLength);
+  let normalIndex = 0;
+  for (i = 0; i < numVertices; ++i) {
+    if (hasSt) {
+      Cartesian2_default.fromArray(st, i * 2, scratchCartesian22);
+      compressedAttributes[normalIndex++] = AttributeCompression_default.compressTextureCoordinates(scratchCartesian22);
+    }
+    const index = i * 3;
+    if (hasNormal && defined_default(tangents) && defined_default(bitangents)) {
+      Cartesian3_default.fromArray(normals, index, toEncode1);
+      Cartesian3_default.fromArray(tangents, index, toEncode2);
+      Cartesian3_default.fromArray(bitangents, index, toEncode3);
+      AttributeCompression_default.octPack(
+        toEncode1,
+        toEncode2,
+        toEncode3,
+        scratchCartesian22
+      );
+      compressedAttributes[normalIndex++] = scratchCartesian22.x;
+      compressedAttributes[normalIndex++] = scratchCartesian22.y;
+    } else {
+      if (hasNormal) {
+        Cartesian3_default.fromArray(normals, index, toEncode1);
+        compressedAttributes[normalIndex++] = AttributeCompression_default.octEncodeFloat(toEncode1);
+      }
+      if (hasTangent) {
+        Cartesian3_default.fromArray(tangents, index, toEncode1);
+        compressedAttributes[normalIndex++] = AttributeCompression_default.octEncodeFloat(toEncode1);
+      }
+      if (hasBitangent) {
+        Cartesian3_default.fromArray(bitangents, index, toEncode1);
+        compressedAttributes[normalIndex++] = AttributeCompression_default.octEncodeFloat(toEncode1);
+      }
+    }
+  }
+  geometry.attributes.compressedAttributes = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.FLOAT,
+    componentsPerAttribute: numCompressedComponents,
+    values: compressedAttributes
+  });
+  if (hasNormal) {
+    delete geometry.attributes.normal;
+  }
+  if (hasSt) {
+    delete geometry.attributes.st;
+  }
+  if (hasBitangent) {
+    delete geometry.attributes.bitangent;
+  }
+  if (hasTangent) {
+    delete geometry.attributes.tangent;
+  }
+  return geometry;
+};
+function indexTriangles(geometry) {
+  if (defined_default(geometry.indices)) {
+    return geometry;
+  }
+  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
+  if (numberOfVertices < 3) {
+    throw new DeveloperError_default("The number of vertices must be at least three.");
+  }
+  if (numberOfVertices % 3 !== 0) {
+    throw new DeveloperError_default(
+      "The number of vertices must be a multiple of three."
+    );
+  }
+  const indices = IndexDatatype_default.createTypedArray(
+    numberOfVertices,
+    numberOfVertices
+  );
+  for (let i = 0; i < numberOfVertices; ++i) {
+    indices[i] = i;
+  }
+  geometry.indices = indices;
+  return geometry;
+}
+function indexTriangleFan(geometry) {
+  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
+  if (numberOfVertices < 3) {
+    throw new DeveloperError_default("The number of vertices must be at least three.");
+  }
+  const indices = IndexDatatype_default.createTypedArray(
+    numberOfVertices,
+    (numberOfVertices - 2) * 3
+  );
+  indices[0] = 1;
+  indices[1] = 0;
+  indices[2] = 2;
+  let indicesIndex = 3;
+  for (let i = 3; i < numberOfVertices; ++i) {
+    indices[indicesIndex++] = i - 1;
+    indices[indicesIndex++] = 0;
+    indices[indicesIndex++] = i;
+  }
+  geometry.indices = indices;
+  geometry.primitiveType = PrimitiveType_default.TRIANGLES;
+  return geometry;
+}
+function indexTriangleStrip(geometry) {
+  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
+  if (numberOfVertices < 3) {
+    throw new DeveloperError_default("The number of vertices must be at least 3.");
+  }
+  const indices = IndexDatatype_default.createTypedArray(
+    numberOfVertices,
+    (numberOfVertices - 2) * 3
+  );
+  indices[0] = 0;
+  indices[1] = 1;
+  indices[2] = 2;
+  if (numberOfVertices > 3) {
+    indices[3] = 0;
+    indices[4] = 2;
+    indices[5] = 3;
+  }
+  let indicesIndex = 6;
+  for (let i = 3; i < numberOfVertices - 1; i += 2) {
+    indices[indicesIndex++] = i;
+    indices[indicesIndex++] = i - 1;
+    indices[indicesIndex++] = i + 1;
+    if (i + 2 < numberOfVertices) {
+      indices[indicesIndex++] = i;
+      indices[indicesIndex++] = i + 1;
+      indices[indicesIndex++] = i + 2;
+    }
+  }
+  geometry.indices = indices;
+  geometry.primitiveType = PrimitiveType_default.TRIANGLES;
+  return geometry;
+}
+function indexLines(geometry) {
+  if (defined_default(geometry.indices)) {
+    return geometry;
+  }
+  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
+  if (numberOfVertices < 2) {
+    throw new DeveloperError_default("The number of vertices must be at least two.");
+  }
+  if (numberOfVertices % 2 !== 0) {
+    throw new DeveloperError_default("The number of vertices must be a multiple of 2.");
+  }
+  const indices = IndexDatatype_default.createTypedArray(
+    numberOfVertices,
+    numberOfVertices
+  );
+  for (let i = 0; i < numberOfVertices; ++i) {
+    indices[i] = i;
+  }
+  geometry.indices = indices;
+  return geometry;
+}
+function indexLineStrip(geometry) {
+  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
+  if (numberOfVertices < 2) {
+    throw new DeveloperError_default("The number of vertices must be at least two.");
+  }
+  const indices = IndexDatatype_default.createTypedArray(
+    numberOfVertices,
+    (numberOfVertices - 1) * 2
+  );
+  indices[0] = 0;
+  indices[1] = 1;
+  let indicesIndex = 2;
+  for (let i = 2; i < numberOfVertices; ++i) {
+    indices[indicesIndex++] = i - 1;
+    indices[indicesIndex++] = i;
+  }
+  geometry.indices = indices;
+  geometry.primitiveType = PrimitiveType_default.LINES;
+  return geometry;
+}
+function indexLineLoop(geometry) {
+  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
+  if (numberOfVertices < 2) {
+    throw new DeveloperError_default("The number of vertices must be at least two.");
+  }
+  const indices = IndexDatatype_default.createTypedArray(
+    numberOfVertices,
+    numberOfVertices * 2
+  );
+  indices[0] = 0;
+  indices[1] = 1;
+  let indicesIndex = 2;
+  for (let i = 2; i < numberOfVertices; ++i) {
+    indices[indicesIndex++] = i - 1;
+    indices[indicesIndex++] = i;
+  }
+  indices[indicesIndex++] = numberOfVertices - 1;
+  indices[indicesIndex] = 0;
+  geometry.indices = indices;
+  geometry.primitiveType = PrimitiveType_default.LINES;
+  return geometry;
+}
+function indexPrimitive(geometry) {
+  switch (geometry.primitiveType) {
+    case PrimitiveType_default.TRIANGLE_FAN:
+      return indexTriangleFan(geometry);
+    case PrimitiveType_default.TRIANGLE_STRIP:
+      return indexTriangleStrip(geometry);
+    case PrimitiveType_default.TRIANGLES:
+      return indexTriangles(geometry);
+    case PrimitiveType_default.LINE_STRIP:
+      return indexLineStrip(geometry);
+    case PrimitiveType_default.LINE_LOOP:
+      return indexLineLoop(geometry);
+    case PrimitiveType_default.LINES:
+      return indexLines(geometry);
+  }
+  return geometry;
+}
+function offsetPointFromXZPlane(p, isBehind) {
+  if (Math.abs(p.y) < Math_default.EPSILON6) {
+    if (isBehind) {
+      p.y = -Math_default.EPSILON6;
+    } else {
+      p.y = Math_default.EPSILON6;
+    }
+  }
+}
+function offsetTriangleFromXZPlane(p0, p1, p2) {
+  if (p0.y !== 0 && p1.y !== 0 && p2.y !== 0) {
+    offsetPointFromXZPlane(p0, p0.y < 0);
+    offsetPointFromXZPlane(p1, p1.y < 0);
+    offsetPointFromXZPlane(p2, p2.y < 0);
+    return;
+  }
+  const p0y = Math.abs(p0.y);
+  const p1y = Math.abs(p1.y);
+  const p2y = Math.abs(p2.y);
+  let sign;
+  if (p0y > p1y) {
+    if (p0y > p2y) {
+      sign = Math_default.sign(p0.y);
+    } else {
+      sign = Math_default.sign(p2.y);
+    }
+  } else if (p1y > p2y) {
+    sign = Math_default.sign(p1.y);
+  } else {
+    sign = Math_default.sign(p2.y);
+  }
+  const isBehind = sign < 0;
+  offsetPointFromXZPlane(p0, isBehind);
+  offsetPointFromXZPlane(p1, isBehind);
+  offsetPointFromXZPlane(p2, isBehind);
+}
+var c3 = new Cartesian3_default();
+function getXZIntersectionOffsetPoints(p, p1, u12, v12) {
+  Cartesian3_default.add(
+    p,
+    Cartesian3_default.multiplyByScalar(
+      Cartesian3_default.subtract(p1, p, c3),
+      p.y / (p.y - p1.y),
+      c3
+    ),
+    u12
+  );
+  Cartesian3_default.clone(u12, v12);
+  offsetPointFromXZPlane(u12, true);
+  offsetPointFromXZPlane(v12, false);
+}
+var u1 = new Cartesian3_default();
+var u2 = new Cartesian3_default();
+var q1 = new Cartesian3_default();
+var q2 = new Cartesian3_default();
+var splitTriangleResult = {
+  positions: new Array(7),
+  indices: new Array(3 * 3)
+};
+function splitTriangle(p0, p1, p2) {
+  if (p0.x >= 0 || p1.x >= 0 || p2.x >= 0) {
+    return void 0;
+  }
+  offsetTriangleFromXZPlane(p0, p1, p2);
+  const p0Behind = p0.y < 0;
+  const p1Behind = p1.y < 0;
+  const p2Behind = p2.y < 0;
+  let numBehind = 0;
+  numBehind += p0Behind ? 1 : 0;
+  numBehind += p1Behind ? 1 : 0;
+  numBehind += p2Behind ? 1 : 0;
+  const indices = splitTriangleResult.indices;
+  if (numBehind === 1) {
+    indices[1] = 3;
+    indices[2] = 4;
+    indices[5] = 6;
+    indices[7] = 6;
+    indices[8] = 5;
+    if (p0Behind) {
+      getXZIntersectionOffsetPoints(p0, p1, u1, q1);
+      getXZIntersectionOffsetPoints(p0, p2, u2, q2);
+      indices[0] = 0;
+      indices[3] = 1;
+      indices[4] = 2;
+      indices[6] = 1;
+    } else if (p1Behind) {
+      getXZIntersectionOffsetPoints(p1, p2, u1, q1);
+      getXZIntersectionOffsetPoints(p1, p0, u2, q2);
+      indices[0] = 1;
+      indices[3] = 2;
+      indices[4] = 0;
+      indices[6] = 2;
+    } else if (p2Behind) {
+      getXZIntersectionOffsetPoints(p2, p0, u1, q1);
+      getXZIntersectionOffsetPoints(p2, p1, u2, q2);
+      indices[0] = 2;
+      indices[3] = 0;
+      indices[4] = 1;
+      indices[6] = 0;
+    }
+  } else if (numBehind === 2) {
+    indices[2] = 4;
+    indices[4] = 4;
+    indices[5] = 3;
+    indices[7] = 5;
+    indices[8] = 6;
+    if (!p0Behind) {
+      getXZIntersectionOffsetPoints(p0, p1, u1, q1);
+      getXZIntersectionOffsetPoints(p0, p2, u2, q2);
+      indices[0] = 1;
+      indices[1] = 2;
+      indices[3] = 1;
+      indices[6] = 0;
+    } else if (!p1Behind) {
+      getXZIntersectionOffsetPoints(p1, p2, u1, q1);
+      getXZIntersectionOffsetPoints(p1, p0, u2, q2);
+      indices[0] = 2;
+      indices[1] = 0;
+      indices[3] = 2;
+      indices[6] = 1;
+    } else if (!p2Behind) {
+      getXZIntersectionOffsetPoints(p2, p0, u1, q1);
+      getXZIntersectionOffsetPoints(p2, p1, u2, q2);
+      indices[0] = 0;
+      indices[1] = 1;
+      indices[3] = 0;
+      indices[6] = 2;
+    }
+  }
+  const positions = splitTriangleResult.positions;
+  positions[0] = p0;
+  positions[1] = p1;
+  positions[2] = p2;
+  positions.length = 3;
+  if (numBehind === 1 || numBehind === 2) {
+    positions[3] = u1;
+    positions[4] = u2;
+    positions[5] = q1;
+    positions[6] = q2;
+    positions.length = 7;
+  }
+  return splitTriangleResult;
+}
+function updateGeometryAfterSplit(geometry, computeBoundingSphere) {
+  const attributes = geometry.attributes;
+  if (attributes.position.values.length === 0) {
+    return void 0;
+  }
+  for (const property in attributes) {
+    if (attributes.hasOwnProperty(property) && defined_default(attributes[property]) && defined_default(attributes[property].values)) {
+      const attribute = attributes[property];
+      attribute.values = ComponentDatatype_default.createTypedArray(
+        attribute.componentDatatype,
+        attribute.values
+      );
+    }
+  }
+  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
+  geometry.indices = IndexDatatype_default.createTypedArray(
+    numberOfVertices,
+    geometry.indices
+  );
+  if (computeBoundingSphere) {
+    geometry.boundingSphere = BoundingSphere_default.fromVertices(
+      attributes.position.values
+    );
+  }
+  return geometry;
+}
+function copyGeometryForSplit(geometry) {
+  const attributes = geometry.attributes;
+  const copiedAttributes = {};
+  for (const property in attributes) {
+    if (attributes.hasOwnProperty(property) && defined_default(attributes[property]) && defined_default(attributes[property].values)) {
+      const attribute = attributes[property];
+      copiedAttributes[property] = new GeometryAttribute_default({
+        componentDatatype: attribute.componentDatatype,
+        componentsPerAttribute: attribute.componentsPerAttribute,
+        normalize: attribute.normalize,
+        values: []
+      });
+    }
+  }
+  return new Geometry_default({
+    attributes: copiedAttributes,
+    indices: [],
+    primitiveType: geometry.primitiveType
+  });
+}
+function updateInstanceAfterSplit(instance, westGeometry, eastGeometry) {
+  const computeBoundingSphere = defined_default(instance.geometry.boundingSphere);
+  westGeometry = updateGeometryAfterSplit(westGeometry, computeBoundingSphere);
+  eastGeometry = updateGeometryAfterSplit(eastGeometry, computeBoundingSphere);
+  if (defined_default(eastGeometry) && !defined_default(westGeometry)) {
+    instance.geometry = eastGeometry;
+  } else if (!defined_default(eastGeometry) && defined_default(westGeometry)) {
+    instance.geometry = westGeometry;
+  } else {
+    instance.westHemisphereGeometry = westGeometry;
+    instance.eastHemisphereGeometry = eastGeometry;
+    instance.geometry = void 0;
+  }
+}
+function generateBarycentricInterpolateFunction(CartesianType, numberOfComponents) {
+  const v0Scratch = new CartesianType();
+  const v1Scratch = new CartesianType();
+  const v2Scratch = new CartesianType();
+  return function(i0, i1, i2, coords, sourceValues, currentValues, insertedIndex, normalize) {
+    const v02 = CartesianType.fromArray(
+      sourceValues,
+      i0 * numberOfComponents,
+      v0Scratch
+    );
+    const v12 = CartesianType.fromArray(
+      sourceValues,
+      i1 * numberOfComponents,
+      v1Scratch
+    );
+    const v22 = CartesianType.fromArray(
+      sourceValues,
+      i2 * numberOfComponents,
+      v2Scratch
+    );
+    CartesianType.multiplyByScalar(v02, coords.x, v02);
+    CartesianType.multiplyByScalar(v12, coords.y, v12);
+    CartesianType.multiplyByScalar(v22, coords.z, v22);
+    const value = CartesianType.add(v02, v12, v02);
+    CartesianType.add(value, v22, value);
+    if (normalize) {
+      CartesianType.normalize(value, value);
+    }
+    CartesianType.pack(
+      value,
+      currentValues,
+      insertedIndex * numberOfComponents
+    );
+  };
+}
+var interpolateAndPackCartesian4 = generateBarycentricInterpolateFunction(
+  Cartesian4_default,
+  4
+);
+var interpolateAndPackCartesian3 = generateBarycentricInterpolateFunction(
+  Cartesian3_default,
+  3
+);
+var interpolateAndPackCartesian2 = generateBarycentricInterpolateFunction(
+  Cartesian2_default,
+  2
+);
+var interpolateAndPackBoolean = function(i0, i1, i2, coords, sourceValues, currentValues, insertedIndex) {
+  const v12 = sourceValues[i0] * coords.x;
+  const v22 = sourceValues[i1] * coords.y;
+  const v3 = sourceValues[i2] * coords.z;
+  currentValues[insertedIndex] = v12 + v22 + v3 > Math_default.EPSILON6 ? 1 : 0;
+};
+var p0Scratch = new Cartesian3_default();
+var p1Scratch = new Cartesian3_default();
+var p2Scratch = new Cartesian3_default();
+var barycentricScratch = new Cartesian3_default();
+function computeTriangleAttributes(i0, i1, i2, point, positions, normals, tangents, bitangents, texCoords, extrudeDirections, applyOffset, currentAttributes, customAttributeNames, customAttributesLength, allAttributes, insertedIndex) {
+  if (!defined_default(normals) && !defined_default(tangents) && !defined_default(bitangents) && !defined_default(texCoords) && !defined_default(extrudeDirections) && customAttributesLength === 0) {
+    return;
+  }
+  const p0 = Cartesian3_default.fromArray(positions, i0 * 3, p0Scratch);
+  const p1 = Cartesian3_default.fromArray(positions, i1 * 3, p1Scratch);
+  const p2 = Cartesian3_default.fromArray(positions, i2 * 3, p2Scratch);
+  const coords = barycentricCoordinates_default(point, p0, p1, p2, barycentricScratch);
+  if (!defined_default(coords)) {
+    return;
+  }
+  if (defined_default(normals)) {
+    interpolateAndPackCartesian3(
+      i0,
+      i1,
+      i2,
+      coords,
+      normals,
+      currentAttributes.normal.values,
+      insertedIndex,
+      true
+    );
+  }
+  if (defined_default(extrudeDirections)) {
+    const d0 = Cartesian3_default.fromArray(extrudeDirections, i0 * 3, p0Scratch);
+    const d1 = Cartesian3_default.fromArray(extrudeDirections, i1 * 3, p1Scratch);
+    const d2 = Cartesian3_default.fromArray(extrudeDirections, i2 * 3, p2Scratch);
+    Cartesian3_default.multiplyByScalar(d0, coords.x, d0);
+    Cartesian3_default.multiplyByScalar(d1, coords.y, d1);
+    Cartesian3_default.multiplyByScalar(d2, coords.z, d2);
+    let direction;
+    if (!Cartesian3_default.equals(d0, Cartesian3_default.ZERO) || !Cartesian3_default.equals(d1, Cartesian3_default.ZERO) || !Cartesian3_default.equals(d2, Cartesian3_default.ZERO)) {
+      direction = Cartesian3_default.add(d0, d1, d0);
+      Cartesian3_default.add(direction, d2, direction);
+      Cartesian3_default.normalize(direction, direction);
+    } else {
+      direction = p0Scratch;
+      direction.x = 0;
+      direction.y = 0;
+      direction.z = 0;
+    }
+    Cartesian3_default.pack(
+      direction,
+      currentAttributes.extrudeDirection.values,
+      insertedIndex * 3
+    );
+  }
+  if (defined_default(applyOffset)) {
+    interpolateAndPackBoolean(
+      i0,
+      i1,
+      i2,
+      coords,
+      applyOffset,
+      currentAttributes.applyOffset.values,
+      insertedIndex
+    );
+  }
+  if (defined_default(tangents)) {
+    interpolateAndPackCartesian3(
+      i0,
+      i1,
+      i2,
+      coords,
+      tangents,
+      currentAttributes.tangent.values,
+      insertedIndex,
+      true
+    );
+  }
+  if (defined_default(bitangents)) {
+    interpolateAndPackCartesian3(
+      i0,
+      i1,
+      i2,
+      coords,
+      bitangents,
+      currentAttributes.bitangent.values,
+      insertedIndex,
+      true
+    );
+  }
+  if (defined_default(texCoords)) {
+    interpolateAndPackCartesian2(
+      i0,
+      i1,
+      i2,
+      coords,
+      texCoords,
+      currentAttributes.st.values,
+      insertedIndex
+    );
+  }
+  if (customAttributesLength > 0) {
+    for (let i = 0; i < customAttributesLength; i++) {
+      const attributeName = customAttributeNames[i];
+      genericInterpolate(
+        i0,
+        i1,
+        i2,
+        coords,
+        insertedIndex,
+        allAttributes[attributeName],
+        currentAttributes[attributeName]
+      );
+    }
+  }
+}
+function genericInterpolate(i0, i1, i2, coords, insertedIndex, sourceAttribute, currentAttribute) {
+  const componentsPerAttribute = sourceAttribute.componentsPerAttribute;
+  const sourceValues = sourceAttribute.values;
+  const currentValues = currentAttribute.values;
+  switch (componentsPerAttribute) {
+    case 4:
+      interpolateAndPackCartesian4(
+        i0,
+        i1,
+        i2,
+        coords,
+        sourceValues,
+        currentValues,
+        insertedIndex,
+        false
+      );
+      break;
+    case 3:
+      interpolateAndPackCartesian3(
+        i0,
+        i1,
+        i2,
+        coords,
+        sourceValues,
+        currentValues,
+        insertedIndex,
+        false
+      );
+      break;
+    case 2:
+      interpolateAndPackCartesian2(
+        i0,
+        i1,
+        i2,
+        coords,
+        sourceValues,
+        currentValues,
+        insertedIndex,
+        false
+      );
+      break;
+    default:
+      currentValues[insertedIndex] = sourceValues[i0] * coords.x + sourceValues[i1] * coords.y + sourceValues[i2] * coords.z;
+  }
+}
+function insertSplitPoint(currentAttributes, currentIndices, currentIndexMap, indices, currentIndex, point) {
+  const insertIndex = currentAttributes.position.values.length / 3;
+  if (currentIndex !== -1) {
+    const prevIndex = indices[currentIndex];
+    const newIndex = currentIndexMap[prevIndex];
+    if (newIndex === -1) {
+      currentIndexMap[prevIndex] = insertIndex;
+      currentAttributes.position.values.push(point.x, point.y, point.z);
+      currentIndices.push(insertIndex);
+      return insertIndex;
+    }
+    currentIndices.push(newIndex);
+    return newIndex;
+  }
+  currentAttributes.position.values.push(point.x, point.y, point.z);
+  currentIndices.push(insertIndex);
+  return insertIndex;
+}
+var NAMED_ATTRIBUTES = {
+  position: true,
+  normal: true,
+  bitangent: true,
+  tangent: true,
+  st: true,
+  extrudeDirection: true,
+  applyOffset: true
+};
+function splitLongitudeTriangles(instance) {
+  const geometry = instance.geometry;
+  const attributes = geometry.attributes;
+  const positions = attributes.position.values;
+  const normals = defined_default(attributes.normal) ? attributes.normal.values : void 0;
+  const bitangents = defined_default(attributes.bitangent) ? attributes.bitangent.values : void 0;
+  const tangents = defined_default(attributes.tangent) ? attributes.tangent.values : void 0;
+  const texCoords = defined_default(attributes.st) ? attributes.st.values : void 0;
+  const extrudeDirections = defined_default(attributes.extrudeDirection) ? attributes.extrudeDirection.values : void 0;
+  const applyOffset = defined_default(attributes.applyOffset) ? attributes.applyOffset.values : void 0;
+  const indices = geometry.indices;
+  const customAttributeNames = [];
+  for (const attributeName in attributes) {
+    if (attributes.hasOwnProperty(attributeName) && !NAMED_ATTRIBUTES[attributeName] && defined_default(attributes[attributeName])) {
+      customAttributeNames.push(attributeName);
+    }
+  }
+  const customAttributesLength = customAttributeNames.length;
+  const eastGeometry = copyGeometryForSplit(geometry);
+  const westGeometry = copyGeometryForSplit(geometry);
+  let currentAttributes;
+  let currentIndices;
+  let currentIndexMap;
+  let insertedIndex;
+  let i;
+  const westGeometryIndexMap = [];
+  westGeometryIndexMap.length = positions.length / 3;
+  const eastGeometryIndexMap = [];
+  eastGeometryIndexMap.length = positions.length / 3;
+  for (i = 0; i < westGeometryIndexMap.length; ++i) {
+    westGeometryIndexMap[i] = -1;
+    eastGeometryIndexMap[i] = -1;
+  }
+  const len = indices.length;
+  for (i = 0; i < len; i += 3) {
+    const i0 = indices[i];
+    const i1 = indices[i + 1];
+    const i2 = indices[i + 2];
+    let p0 = Cartesian3_default.fromArray(positions, i0 * 3);
+    let p1 = Cartesian3_default.fromArray(positions, i1 * 3);
+    let p2 = Cartesian3_default.fromArray(positions, i2 * 3);
+    const result = splitTriangle(p0, p1, p2);
+    if (defined_default(result) && result.positions.length > 3) {
+      const resultPositions = result.positions;
+      const resultIndices = result.indices;
+      const resultLength = resultIndices.length;
+      for (let j = 0; j < resultLength; ++j) {
+        const resultIndex = resultIndices[j];
+        const point = resultPositions[resultIndex];
+        if (point.y < 0) {
+          currentAttributes = westGeometry.attributes;
+          currentIndices = westGeometry.indices;
+          currentIndexMap = westGeometryIndexMap;
+        } else {
+          currentAttributes = eastGeometry.attributes;
+          currentIndices = eastGeometry.indices;
+          currentIndexMap = eastGeometryIndexMap;
+        }
+        insertedIndex = insertSplitPoint(
+          currentAttributes,
+          currentIndices,
+          currentIndexMap,
+          indices,
+          resultIndex < 3 ? i + resultIndex : -1,
+          point
+        );
+        computeTriangleAttributes(
+          i0,
+          i1,
+          i2,
+          point,
+          positions,
+          normals,
+          tangents,
+          bitangents,
+          texCoords,
+          extrudeDirections,
+          applyOffset,
+          currentAttributes,
+          customAttributeNames,
+          customAttributesLength,
+          attributes,
+          insertedIndex
+        );
+      }
+    } else {
+      if (defined_default(result)) {
+        p0 = result.positions[0];
+        p1 = result.positions[1];
+        p2 = result.positions[2];
+      }
+      if (p0.y < 0) {
+        currentAttributes = westGeometry.attributes;
+        currentIndices = westGeometry.indices;
+        currentIndexMap = westGeometryIndexMap;
+      } else {
+        currentAttributes = eastGeometry.attributes;
+        currentIndices = eastGeometry.indices;
+        currentIndexMap = eastGeometryIndexMap;
+      }
+      insertedIndex = insertSplitPoint(
+        currentAttributes,
+        currentIndices,
+        currentIndexMap,
+        indices,
+        i,
+        p0
+      );
+      computeTriangleAttributes(
+        i0,
+        i1,
+        i2,
+        p0,
+        positions,
+        normals,
+        tangents,
+        bitangents,
+        texCoords,
+        extrudeDirections,
+        applyOffset,
+        currentAttributes,
+        customAttributeNames,
+        customAttributesLength,
+        attributes,
+        insertedIndex
+      );
+      insertedIndex = insertSplitPoint(
+        currentAttributes,
+        currentIndices,
+        currentIndexMap,
+        indices,
+        i + 1,
+        p1
+      );
+      computeTriangleAttributes(
+        i0,
+        i1,
+        i2,
+        p1,
+        positions,
+        normals,
+        tangents,
+        bitangents,
+        texCoords,
+        extrudeDirections,
+        applyOffset,
+        currentAttributes,
+        customAttributeNames,
+        customAttributesLength,
+        attributes,
+        insertedIndex
+      );
+      insertedIndex = insertSplitPoint(
+        currentAttributes,
+        currentIndices,
+        currentIndexMap,
+        indices,
+        i + 2,
+        p2
+      );
+      computeTriangleAttributes(
+        i0,
+        i1,
+        i2,
+        p2,
+        positions,
+        normals,
+        tangents,
+        bitangents,
+        texCoords,
+        extrudeDirections,
+        applyOffset,
+        currentAttributes,
+        customAttributeNames,
+        customAttributesLength,
+        attributes,
+        insertedIndex
+      );
+    }
+  }
+  updateInstanceAfterSplit(instance, westGeometry, eastGeometry);
+}
+var xzPlane = Plane_default.fromPointNormal(Cartesian3_default.ZERO, Cartesian3_default.UNIT_Y);
+var offsetScratch = new Cartesian3_default();
+var offsetPointScratch = new Cartesian3_default();
+function computeLineAttributes(i0, i1, point, positions, insertIndex, currentAttributes, applyOffset) {
+  if (!defined_default(applyOffset)) {
+    return;
+  }
+  const p0 = Cartesian3_default.fromArray(positions, i0 * 3, p0Scratch);
+  if (Cartesian3_default.equalsEpsilon(p0, point, Math_default.EPSILON10)) {
+    currentAttributes.applyOffset.values[insertIndex] = applyOffset[i0];
+  } else {
+    currentAttributes.applyOffset.values[insertIndex] = applyOffset[i1];
+  }
+}
+function splitLongitudeLines(instance) {
+  const geometry = instance.geometry;
+  const attributes = geometry.attributes;
+  const positions = attributes.position.values;
+  const applyOffset = defined_default(attributes.applyOffset) ? attributes.applyOffset.values : void 0;
+  const indices = geometry.indices;
+  const eastGeometry = copyGeometryForSplit(geometry);
+  const westGeometry = copyGeometryForSplit(geometry);
+  let i;
+  const length = indices.length;
+  const westGeometryIndexMap = [];
+  westGeometryIndexMap.length = positions.length / 3;
+  const eastGeometryIndexMap = [];
+  eastGeometryIndexMap.length = positions.length / 3;
+  for (i = 0; i < westGeometryIndexMap.length; ++i) {
+    westGeometryIndexMap[i] = -1;
+    eastGeometryIndexMap[i] = -1;
+  }
+  for (i = 0; i < length; i += 2) {
+    const i0 = indices[i];
+    const i1 = indices[i + 1];
+    const p0 = Cartesian3_default.fromArray(positions, i0 * 3, p0Scratch);
+    const p1 = Cartesian3_default.fromArray(positions, i1 * 3, p1Scratch);
+    let insertIndex;
+    if (Math.abs(p0.y) < Math_default.EPSILON6) {
+      if (p0.y < 0) {
+        p0.y = -Math_default.EPSILON6;
+      } else {
+        p0.y = Math_default.EPSILON6;
+      }
+    }
+    if (Math.abs(p1.y) < Math_default.EPSILON6) {
+      if (p1.y < 0) {
+        p1.y = -Math_default.EPSILON6;
+      } else {
+        p1.y = Math_default.EPSILON6;
+      }
+    }
+    let p0Attributes = eastGeometry.attributes;
+    let p0Indices = eastGeometry.indices;
+    let p0IndexMap = eastGeometryIndexMap;
+    let p1Attributes = westGeometry.attributes;
+    let p1Indices = westGeometry.indices;
+    let p1IndexMap = westGeometryIndexMap;
+    const intersection = IntersectionTests_default.lineSegmentPlane(
+      p0,
+      p1,
+      xzPlane,
+      p2Scratch
+    );
+    if (defined_default(intersection)) {
+      const offset = Cartesian3_default.multiplyByScalar(
+        Cartesian3_default.UNIT_Y,
+        5 * Math_default.EPSILON9,
+        offsetScratch
+      );
+      if (p0.y < 0) {
+        Cartesian3_default.negate(offset, offset);
+        p0Attributes = westGeometry.attributes;
+        p0Indices = westGeometry.indices;
+        p0IndexMap = westGeometryIndexMap;
+        p1Attributes = eastGeometry.attributes;
+        p1Indices = eastGeometry.indices;
+        p1IndexMap = eastGeometryIndexMap;
+      }
+      const offsetPoint = Cartesian3_default.add(
+        intersection,
+        offset,
+        offsetPointScratch
+      );
+      insertIndex = insertSplitPoint(
+        p0Attributes,
+        p0Indices,
+        p0IndexMap,
+        indices,
+        i,
+        p0
+      );
+      computeLineAttributes(
+        i0,
+        i1,
+        p0,
+        positions,
+        insertIndex,
+        p0Attributes,
+        applyOffset
+      );
+      insertIndex = insertSplitPoint(
+        p0Attributes,
+        p0Indices,
+        p0IndexMap,
+        indices,
+        -1,
+        offsetPoint
+      );
+      computeLineAttributes(
+        i0,
+        i1,
+        offsetPoint,
+        positions,
+        insertIndex,
+        p0Attributes,
+        applyOffset
+      );
+      Cartesian3_default.negate(offset, offset);
+      Cartesian3_default.add(intersection, offset, offsetPoint);
+      insertIndex = insertSplitPoint(
+        p1Attributes,
+        p1Indices,
+        p1IndexMap,
+        indices,
+        -1,
+        offsetPoint
+      );
+      computeLineAttributes(
+        i0,
+        i1,
+        offsetPoint,
+        positions,
+        insertIndex,
+        p1Attributes,
+        applyOffset
+      );
+      insertIndex = insertSplitPoint(
+        p1Attributes,
+        p1Indices,
+        p1IndexMap,
+        indices,
+        i + 1,
+        p1
+      );
+      computeLineAttributes(
+        i0,
+        i1,
+        p1,
+        positions,
+        insertIndex,
+        p1Attributes,
+        applyOffset
+      );
+    } else {
+      let currentAttributes;
+      let currentIndices;
+      let currentIndexMap;
+      if (p0.y < 0) {
+        currentAttributes = westGeometry.attributes;
+        currentIndices = westGeometry.indices;
+        currentIndexMap = westGeometryIndexMap;
+      } else {
+        currentAttributes = eastGeometry.attributes;
+        currentIndices = eastGeometry.indices;
+        currentIndexMap = eastGeometryIndexMap;
+      }
+      insertIndex = insertSplitPoint(
+        currentAttributes,
+        currentIndices,
+        currentIndexMap,
+        indices,
+        i,
+        p0
+      );
+      computeLineAttributes(
+        i0,
+        i1,
+        p0,
+        positions,
+        insertIndex,
+        currentAttributes,
+        applyOffset
+      );
+      insertIndex = insertSplitPoint(
+        currentAttributes,
+        currentIndices,
+        currentIndexMap,
+        indices,
+        i + 1,
+        p1
+      );
+      computeLineAttributes(
+        i0,
+        i1,
+        p1,
+        positions,
+        insertIndex,
+        currentAttributes,
+        applyOffset
+      );
+    }
+  }
+  updateInstanceAfterSplit(instance, westGeometry, eastGeometry);
+}
+var cartesian2Scratch0 = new Cartesian2_default();
+var cartesian2Scratch1 = new Cartesian2_default();
+var cartesian3Scratch0 = new Cartesian3_default();
+var cartesian3Scratch2 = new Cartesian3_default();
+var cartesian3Scratch3 = new Cartesian3_default();
+var cartesian3Scratch4 = new Cartesian3_default();
+var cartesian3Scratch5 = new Cartesian3_default();
+var cartesian3Scratch6 = new Cartesian3_default();
+var cartesian4Scratch0 = new Cartesian4_default();
+function updateAdjacencyAfterSplit(geometry) {
+  const attributes = geometry.attributes;
+  const positions = attributes.position.values;
+  const prevPositions = attributes.prevPosition.values;
+  const nextPositions = attributes.nextPosition.values;
+  const length = positions.length;
+  for (let j = 0; j < length; j += 3) {
+    const position = Cartesian3_default.unpack(positions, j, cartesian3Scratch0);
+    if (position.x > 0) {
+      continue;
+    }
+    const prevPosition = Cartesian3_default.unpack(
+      prevPositions,
+      j,
+      cartesian3Scratch2
+    );
+    if (position.y < 0 && prevPosition.y > 0 || position.y > 0 && prevPosition.y < 0) {
+      if (j - 3 > 0) {
+        prevPositions[j] = positions[j - 3];
+        prevPositions[j + 1] = positions[j - 2];
+        prevPositions[j + 2] = positions[j - 1];
+      } else {
+        Cartesian3_default.pack(position, prevPositions, j);
+      }
+    }
+    const nextPosition = Cartesian3_default.unpack(
+      nextPositions,
+      j,
+      cartesian3Scratch3
+    );
+    if (position.y < 0 && nextPosition.y > 0 || position.y > 0 && nextPosition.y < 0) {
+      if (j + 3 < length) {
+        nextPositions[j] = positions[j + 3];
+        nextPositions[j + 1] = positions[j + 4];
+        nextPositions[j + 2] = positions[j + 5];
+      } else {
+        Cartesian3_default.pack(position, nextPositions, j);
+      }
+    }
+  }
+}
+var offsetScalar = 5 * Math_default.EPSILON9;
+var coplanarOffset = Math_default.EPSILON6;
+function splitLongitudePolyline(instance) {
+  const geometry = instance.geometry;
+  const attributes = geometry.attributes;
+  const positions = attributes.position.values;
+  const prevPositions = attributes.prevPosition.values;
+  const nextPositions = attributes.nextPosition.values;
+  const expandAndWidths = attributes.expandAndWidth.values;
+  const texCoords = defined_default(attributes.st) ? attributes.st.values : void 0;
+  const colors = defined_default(attributes.color) ? attributes.color.values : void 0;
+  const eastGeometry = copyGeometryForSplit(geometry);
+  const westGeometry = copyGeometryForSplit(geometry);
+  let i;
+  let j;
+  let index;
+  let intersectionFound = false;
+  const length = positions.length / 3;
+  for (i = 0; i < length; i += 4) {
+    const i0 = i;
+    const i2 = i + 2;
+    const p0 = Cartesian3_default.fromArray(positions, i0 * 3, cartesian3Scratch0);
+    const p2 = Cartesian3_default.fromArray(positions, i2 * 3, cartesian3Scratch2);
+    if (Math.abs(p0.y) < coplanarOffset) {
+      p0.y = coplanarOffset * (p2.y < 0 ? -1 : 1);
+      positions[i * 3 + 1] = p0.y;
+      positions[(i + 1) * 3 + 1] = p0.y;
+      for (j = i0 * 3; j < i0 * 3 + 4 * 3; j += 3) {
+        prevPositions[j] = positions[i * 3];
+        prevPositions[j + 1] = positions[i * 3 + 1];
+        prevPositions[j + 2] = positions[i * 3 + 2];
+      }
+    }
+    if (Math.abs(p2.y) < coplanarOffset) {
+      p2.y = coplanarOffset * (p0.y < 0 ? -1 : 1);
+      positions[(i + 2) * 3 + 1] = p2.y;
+      positions[(i + 3) * 3 + 1] = p2.y;
+      for (j = i0 * 3; j < i0 * 3 + 4 * 3; j += 3) {
+        nextPositions[j] = positions[(i + 2) * 3];
+        nextPositions[j + 1] = positions[(i + 2) * 3 + 1];
+        nextPositions[j + 2] = positions[(i + 2) * 3 + 2];
+      }
+    }
+    let p0Attributes = eastGeometry.attributes;
+    let p0Indices = eastGeometry.indices;
+    let p2Attributes = westGeometry.attributes;
+    let p2Indices = westGeometry.indices;
+    const intersection = IntersectionTests_default.lineSegmentPlane(
+      p0,
+      p2,
+      xzPlane,
+      cartesian3Scratch4
+    );
+    if (defined_default(intersection)) {
+      intersectionFound = true;
+      const offset = Cartesian3_default.multiplyByScalar(
+        Cartesian3_default.UNIT_Y,
+        offsetScalar,
+        cartesian3Scratch5
+      );
+      if (p0.y < 0) {
+        Cartesian3_default.negate(offset, offset);
+        p0Attributes = westGeometry.attributes;
+        p0Indices = westGeometry.indices;
+        p2Attributes = eastGeometry.attributes;
+        p2Indices = eastGeometry.indices;
+      }
+      const offsetPoint = Cartesian3_default.add(
+        intersection,
+        offset,
+        cartesian3Scratch6
+      );
+      p0Attributes.position.values.push(p0.x, p0.y, p0.z, p0.x, p0.y, p0.z);
+      p0Attributes.position.values.push(
+        offsetPoint.x,
+        offsetPoint.y,
+        offsetPoint.z
+      );
+      p0Attributes.position.values.push(
+        offsetPoint.x,
+        offsetPoint.y,
+        offsetPoint.z
+      );
+      p0Attributes.prevPosition.values.push(
+        prevPositions[i0 * 3],
+        prevPositions[i0 * 3 + 1],
+        prevPositions[i0 * 3 + 2]
+      );
+      p0Attributes.prevPosition.values.push(
+        prevPositions[i0 * 3 + 3],
+        prevPositions[i0 * 3 + 4],
+        prevPositions[i0 * 3 + 5]
+      );
+      p0Attributes.prevPosition.values.push(p0.x, p0.y, p0.z, p0.x, p0.y, p0.z);
+      p0Attributes.nextPosition.values.push(
+        offsetPoint.x,
+        offsetPoint.y,
+        offsetPoint.z
+      );
+      p0Attributes.nextPosition.values.push(
+        offsetPoint.x,
+        offsetPoint.y,
+        offsetPoint.z
+      );
+      p0Attributes.nextPosition.values.push(
+        offsetPoint.x,
+        offsetPoint.y,
+        offsetPoint.z
+      );
+      p0Attributes.nextPosition.values.push(
+        offsetPoint.x,
+        offsetPoint.y,
+        offsetPoint.z
+      );
+      Cartesian3_default.negate(offset, offset);
+      Cartesian3_default.add(intersection, offset, offsetPoint);
+      p2Attributes.position.values.push(
+        offsetPoint.x,
+        offsetPoint.y,
+        offsetPoint.z
+      );
+      p2Attributes.position.values.push(
+        offsetPoint.x,
+        offsetPoint.y,
+        offsetPoint.z
+      );
+      p2Attributes.position.values.push(p2.x, p2.y, p2.z, p2.x, p2.y, p2.z);
+      p2Attributes.prevPosition.values.push(
+        offsetPoint.x,
+        offsetPoint.y,
+        offsetPoint.z
+      );
+      p2Attributes.prevPosition.values.push(
+        offsetPoint.x,
+        offsetPoint.y,
+        offsetPoint.z
+      );
+      p2Attributes.prevPosition.values.push(
+        offsetPoint.x,
+        offsetPoint.y,
+        offsetPoint.z
+      );
+      p2Attributes.prevPosition.values.push(
+        offsetPoint.x,
+        offsetPoint.y,
+        offsetPoint.z
+      );
+      p2Attributes.nextPosition.values.push(p2.x, p2.y, p2.z, p2.x, p2.y, p2.z);
+      p2Attributes.nextPosition.values.push(
+        nextPositions[i2 * 3],
+        nextPositions[i2 * 3 + 1],
+        nextPositions[i2 * 3 + 2]
+      );
+      p2Attributes.nextPosition.values.push(
+        nextPositions[i2 * 3 + 3],
+        nextPositions[i2 * 3 + 4],
+        nextPositions[i2 * 3 + 5]
+      );
+      const ew0 = Cartesian2_default.fromArray(
+        expandAndWidths,
+        i0 * 2,
+        cartesian2Scratch0
+      );
+      const width = Math.abs(ew0.y);
+      p0Attributes.expandAndWidth.values.push(-1, width, 1, width);
+      p0Attributes.expandAndWidth.values.push(-1, -width, 1, -width);
+      p2Attributes.expandAndWidth.values.push(-1, width, 1, width);
+      p2Attributes.expandAndWidth.values.push(-1, -width, 1, -width);
+      let t = Cartesian3_default.magnitudeSquared(
+        Cartesian3_default.subtract(intersection, p0, cartesian3Scratch3)
+      );
+      t /= Cartesian3_default.magnitudeSquared(
+        Cartesian3_default.subtract(p2, p0, cartesian3Scratch3)
+      );
+      if (defined_default(colors)) {
+        const c0 = Cartesian4_default.fromArray(colors, i0 * 4, cartesian4Scratch0);
+        const c2 = Cartesian4_default.fromArray(colors, i2 * 4, cartesian4Scratch0);
+        const r = Math_default.lerp(c0.x, c2.x, t);
+        const g = Math_default.lerp(c0.y, c2.y, t);
+        const b = Math_default.lerp(c0.z, c2.z, t);
+        const a = Math_default.lerp(c0.w, c2.w, t);
+        for (j = i0 * 4; j < i0 * 4 + 2 * 4; ++j) {
+          p0Attributes.color.values.push(colors[j]);
+        }
+        p0Attributes.color.values.push(r, g, b, a);
+        p0Attributes.color.values.push(r, g, b, a);
+        p2Attributes.color.values.push(r, g, b, a);
+        p2Attributes.color.values.push(r, g, b, a);
+        for (j = i2 * 4; j < i2 * 4 + 2 * 4; ++j) {
+          p2Attributes.color.values.push(colors[j]);
+        }
+      }
+      if (defined_default(texCoords)) {
+        const s0 = Cartesian2_default.fromArray(texCoords, i0 * 2, cartesian2Scratch0);
+        const s3 = Cartesian2_default.fromArray(
+          texCoords,
+          (i + 3) * 2,
+          cartesian2Scratch1
+        );
+        const sx = Math_default.lerp(s0.x, s3.x, t);
+        for (j = i0 * 2; j < i0 * 2 + 2 * 2; ++j) {
+          p0Attributes.st.values.push(texCoords[j]);
+        }
+        p0Attributes.st.values.push(sx, s0.y);
+        p0Attributes.st.values.push(sx, s3.y);
+        p2Attributes.st.values.push(sx, s0.y);
+        p2Attributes.st.values.push(sx, s3.y);
+        for (j = i2 * 2; j < i2 * 2 + 2 * 2; ++j) {
+          p2Attributes.st.values.push(texCoords[j]);
+        }
+      }
+      index = p0Attributes.position.values.length / 3 - 4;
+      p0Indices.push(index, index + 2, index + 1);
+      p0Indices.push(index + 1, index + 2, index + 3);
+      index = p2Attributes.position.values.length / 3 - 4;
+      p2Indices.push(index, index + 2, index + 1);
+      p2Indices.push(index + 1, index + 2, index + 3);
+    } else {
+      let currentAttributes;
+      let currentIndices;
+      if (p0.y < 0) {
+        currentAttributes = westGeometry.attributes;
+        currentIndices = westGeometry.indices;
+      } else {
+        currentAttributes = eastGeometry.attributes;
+        currentIndices = eastGeometry.indices;
+      }
+      currentAttributes.position.values.push(p0.x, p0.y, p0.z);
+      currentAttributes.position.values.push(p0.x, p0.y, p0.z);
+      currentAttributes.position.values.push(p2.x, p2.y, p2.z);
+      currentAttributes.position.values.push(p2.x, p2.y, p2.z);
+      for (j = i * 3; j < i * 3 + 4 * 3; ++j) {
+        currentAttributes.prevPosition.values.push(prevPositions[j]);
+        currentAttributes.nextPosition.values.push(nextPositions[j]);
+      }
+      for (j = i * 2; j < i * 2 + 4 * 2; ++j) {
+        currentAttributes.expandAndWidth.values.push(expandAndWidths[j]);
+        if (defined_default(texCoords)) {
+          currentAttributes.st.values.push(texCoords[j]);
+        }
+      }
+      if (defined_default(colors)) {
+        for (j = i * 4; j < i * 4 + 4 * 4; ++j) {
+          currentAttributes.color.values.push(colors[j]);
+        }
+      }
+      index = currentAttributes.position.values.length / 3 - 4;
+      currentIndices.push(index, index + 2, index + 1);
+      currentIndices.push(index + 1, index + 2, index + 3);
+    }
+  }
+  if (intersectionFound) {
+    updateAdjacencyAfterSplit(westGeometry);
+    updateAdjacencyAfterSplit(eastGeometry);
+  }
+  updateInstanceAfterSplit(instance, westGeometry, eastGeometry);
+}
+GeometryPipeline.splitLongitude = function(instance) {
+  if (!defined_default(instance)) {
+    throw new DeveloperError_default("instance is required.");
+  }
+  const geometry = instance.geometry;
+  const boundingSphere = geometry.boundingSphere;
+  if (defined_default(boundingSphere)) {
+    const minX = boundingSphere.center.x - boundingSphere.radius;
+    if (minX > 0 || BoundingSphere_default.intersectPlane(boundingSphere, Plane_default.ORIGIN_ZX_PLANE) !== Intersect_default.INTERSECTING) {
+      return instance;
+    }
+  }
+  if (geometry.geometryType !== GeometryType_default.NONE) {
+    switch (geometry.geometryType) {
+      case GeometryType_default.POLYLINES:
+        splitLongitudePolyline(instance);
+        break;
+      case GeometryType_default.TRIANGLES:
+        splitLongitudeTriangles(instance);
+        break;
+      case GeometryType_default.LINES:
+        splitLongitudeLines(instance);
+        break;
+    }
+  } else {
+    indexPrimitive(geometry);
+    if (geometry.primitiveType === PrimitiveType_default.TRIANGLES) {
+      splitLongitudeTriangles(instance);
+    } else if (geometry.primitiveType === PrimitiveType_default.LINES) {
+      splitLongitudeLines(instance);
+    }
+  }
+  return instance;
+};
+var GeometryPipeline_default = GeometryPipeline;
+
+export {
+  GeometryPipeline_default
+};

public/assets/cesium/Workers/chunk-BVKITG4N.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  GeographicProjection_default
+} from "./chunk-KHZNBFOH.js";
+import {
+  Matrix2_default,
+  Rectangle_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  Cartesian3_default,
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import {
+  DeveloperError_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/RectangleGeometryLibrary.js
+var cos = Math.cos;
+var sin = Math.sin;
+var sqrt = Math.sqrt;
+var RectangleGeometryLibrary = {};
+RectangleGeometryLibrary.computePosition = function(computedOptions, ellipsoid, computeST, row, col, position, st) {
+  const radiiSquared = ellipsoid.radiiSquared;
+  const nwCorner = computedOptions.nwCorner;
+  const rectangle = computedOptions.boundingRectangle;
+  let stLatitude = nwCorner.latitude - computedOptions.granYCos * row + col * computedOptions.granXSin;
+  const cosLatitude = cos(stLatitude);
+  const nZ = sin(stLatitude);
+  const kZ = radiiSquared.z * nZ;
+  let stLongitude = nwCorner.longitude + row * computedOptions.granYSin + col * computedOptions.granXCos;
+  const nX = cosLatitude * cos(stLongitude);
+  const nY = cosLatitude * sin(stLongitude);
+  const kX = radiiSquared.x * nX;
+  const kY = radiiSquared.y * nY;
+  const gamma = sqrt(kX * nX + kY * nY + kZ * nZ);
+  position.x = kX / gamma;
+  position.y = kY / gamma;
+  position.z = kZ / gamma;
+  if (computeST) {
+    const stNwCorner = computedOptions.stNwCorner;
+    if (defined_default(stNwCorner)) {
+      stLatitude = stNwCorner.latitude - computedOptions.stGranYCos * row + col * computedOptions.stGranXSin;
+      stLongitude = stNwCorner.longitude + row * computedOptions.stGranYSin + col * computedOptions.stGranXCos;
+      st.x = (stLongitude - computedOptions.stWest) * computedOptions.lonScalar;
+      st.y = (stLatitude - computedOptions.stSouth) * computedOptions.latScalar;
+    } else {
+      st.x = (stLongitude - rectangle.west) * computedOptions.lonScalar;
+      st.y = (stLatitude - rectangle.south) * computedOptions.latScalar;
+    }
+  }
+};
+var rotationMatrixScratch = new Matrix2_default();
+var nwCartesian = new Cartesian3_default();
+var centerScratch = new Cartographic_default();
+var centerCartesian = new Cartesian3_default();
+var proj = new GeographicProjection_default();
+function getRotationOptions(nwCorner, rotation, granularityX, granularityY, center, width, height) {
+  const cosRotation = Math.cos(rotation);
+  const granYCos = granularityY * cosRotation;
+  const granXCos = granularityX * cosRotation;
+  const sinRotation = Math.sin(rotation);
+  const granYSin = granularityY * sinRotation;
+  const granXSin = granularityX * sinRotation;
+  proj._ellipsoid = Ellipsoid_default.default;
+  nwCartesian = proj.project(nwCorner, nwCartesian);
+  nwCartesian = Cartesian3_default.subtract(nwCartesian, centerCartesian, nwCartesian);
+  const rotationMatrix = Matrix2_default.fromRotation(rotation, rotationMatrixScratch);
+  nwCartesian = Matrix2_default.multiplyByVector(
+    rotationMatrix,
+    nwCartesian,
+    nwCartesian
+  );
+  nwCartesian = Cartesian3_default.add(nwCartesian, centerCartesian, nwCartesian);
+  nwCorner = proj.unproject(nwCartesian, nwCorner);
+  width -= 1;
+  height -= 1;
+  const latitude = nwCorner.latitude;
+  const latitude0 = latitude + width * granXSin;
+  const latitude1 = latitude - granYCos * height;
+  const latitude2 = latitude - granYCos * height + width * granXSin;
+  const north = Math.max(latitude, latitude0, latitude1, latitude2);
+  const south = Math.min(latitude, latitude0, latitude1, latitude2);
+  const longitude = nwCorner.longitude;
+  const longitude0 = longitude + width * granXCos;
+  const longitude1 = longitude + height * granYSin;
+  const longitude2 = longitude + height * granYSin + width * granXCos;
+  const east = Math.max(longitude, longitude0, longitude1, longitude2);
+  const west = Math.min(longitude, longitude0, longitude1, longitude2);
+  return {
+    north,
+    south,
+    east,
+    west,
+    granYCos,
+    granYSin,
+    granXCos,
+    granXSin,
+    nwCorner
+  };
+}
+RectangleGeometryLibrary.computeOptions = function(rectangle, granularity, rotation, stRotation, boundingRectangleScratch, nwCornerResult, stNwCornerResult) {
+  let east = rectangle.east;
+  let west = rectangle.west;
+  let north = rectangle.north;
+  let south = rectangle.south;
+  let northCap = false;
+  let southCap = false;
+  if (north === Math_default.PI_OVER_TWO) {
+    northCap = true;
+  }
+  if (south === -Math_default.PI_OVER_TWO) {
+    southCap = true;
+  }
+  let dx;
+  const dy = north - south;
+  if (west > east) {
+    dx = Math_default.TWO_PI - west + east;
+  } else {
+    dx = east - west;
+  }
+  const width = Math.ceil(dx / granularity) + 1;
+  const height = Math.ceil(dy / granularity) + 1;
+  const granularityX = dx / (width - 1);
+  const granularityY = dy / (height - 1);
+  const nwCorner = Rectangle_default.northwest(rectangle, nwCornerResult);
+  const center = Rectangle_default.center(rectangle, centerScratch);
+  if (rotation !== 0 || stRotation !== 0) {
+    if (center.longitude < nwCorner.longitude) {
+      center.longitude += Math_default.TWO_PI;
+    }
+    proj._ellipsoid = Ellipsoid_default.default;
+    centerCartesian = proj.project(center, centerCartesian);
+  }
+  const granYCos = granularityY;
+  const granXCos = granularityX;
+  const granYSin = 0;
+  const granXSin = 0;
+  const boundingRectangle = Rectangle_default.clone(
+    rectangle,
+    boundingRectangleScratch
+  );
+  const computedOptions = {
+    granYCos,
+    granYSin,
+    granXCos,
+    granXSin,
+    nwCorner,
+    boundingRectangle,
+    width,
+    height,
+    northCap,
+    southCap
+  };
+  if (rotation !== 0) {
+    const rotationOptions = getRotationOptions(
+      nwCorner,
+      rotation,
+      granularityX,
+      granularityY,
+      center,
+      width,
+      height
+    );
+    north = rotationOptions.north;
+    south = rotationOptions.south;
+    east = rotationOptions.east;
+    west = rotationOptions.west;
+    if (north < -Math_default.PI_OVER_TWO || north > Math_default.PI_OVER_TWO || south < -Math_default.PI_OVER_TWO || south > Math_default.PI_OVER_TWO) {
+      throw new DeveloperError_default(
+        "Rotated rectangle is invalid.  It crosses over either the north or south pole."
+      );
+    }
+    computedOptions.granYCos = rotationOptions.granYCos;
+    computedOptions.granYSin = rotationOptions.granYSin;
+    computedOptions.granXCos = rotationOptions.granXCos;
+    computedOptions.granXSin = rotationOptions.granXSin;
+    boundingRectangle.north = north;
+    boundingRectangle.south = south;
+    boundingRectangle.east = east;
+    boundingRectangle.west = west;
+  }
+  if (stRotation !== 0) {
+    rotation = rotation - stRotation;
+    const stNwCorner = Rectangle_default.northwest(boundingRectangle, stNwCornerResult);
+    const stRotationOptions = getRotationOptions(
+      stNwCorner,
+      rotation,
+      granularityX,
+      granularityY,
+      center,
+      width,
+      height
+    );
+    computedOptions.stGranYCos = stRotationOptions.granYCos;
+    computedOptions.stGranXCos = stRotationOptions.granXCos;
+    computedOptions.stGranYSin = stRotationOptions.granYSin;
+    computedOptions.stGranXSin = stRotationOptions.granXSin;
+    computedOptions.stNwCorner = stNwCorner;
+    computedOptions.stWest = stRotationOptions.west;
+    computedOptions.stSouth = stRotationOptions.south;
+  }
+  return computedOptions;
+};
+var RectangleGeometryLibrary_default = RectangleGeometryLibrary;
+
+export {
+  RectangleGeometryLibrary_default
+};

public/assets/cesium/Workers/chunk-C3EQ27WF.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  Cartesian3_default,
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import {
+  defaultValue_default
+} from "./chunk-U5HSOKPQ.js";
+import {
+  Check_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/EllipsoidGeodesic.js
+function setConstants(ellipsoidGeodesic) {
+  const uSquared = ellipsoidGeodesic._uSquared;
+  const a = ellipsoidGeodesic._ellipsoid.maximumRadius;
+  const b = ellipsoidGeodesic._ellipsoid.minimumRadius;
+  const f = (a - b) / a;
+  const cosineHeading = Math.cos(ellipsoidGeodesic._startHeading);
+  const sineHeading = Math.sin(ellipsoidGeodesic._startHeading);
+  const tanU = (1 - f) * Math.tan(ellipsoidGeodesic._start.latitude);
+  const cosineU = 1 / Math.sqrt(1 + tanU * tanU);
+  const sineU = cosineU * tanU;
+  const sigma = Math.atan2(tanU, cosineHeading);
+  const sineAlpha = cosineU * sineHeading;
+  const sineSquaredAlpha = sineAlpha * sineAlpha;
+  const cosineSquaredAlpha = 1 - sineSquaredAlpha;
+  const cosineAlpha = Math.sqrt(cosineSquaredAlpha);
+  const u2Over4 = uSquared / 4;
+  const u4Over16 = u2Over4 * u2Over4;
+  const u6Over64 = u4Over16 * u2Over4;
+  const u8Over256 = u4Over16 * u4Over16;
+  const a0 = 1 + u2Over4 - 3 * u4Over16 / 4 + 5 * u6Over64 / 4 - 175 * u8Over256 / 64;
+  const a1 = 1 - u2Over4 + 15 * u4Over16 / 8 - 35 * u6Over64 / 8;
+  const a2 = 1 - 3 * u2Over4 + 35 * u4Over16 / 4;
+  const a3 = 1 - 5 * u2Over4;
+  const distanceRatio = a0 * sigma - a1 * Math.sin(2 * sigma) * u2Over4 / 2 - a2 * Math.sin(4 * sigma) * u4Over16 / 16 - a3 * Math.sin(6 * sigma) * u6Over64 / 48 - Math.sin(8 * sigma) * 5 * u8Over256 / 512;
+  const constants = ellipsoidGeodesic._constants;
+  constants.a = a;
+  constants.b = b;
+  constants.f = f;
+  constants.cosineHeading = cosineHeading;
+  constants.sineHeading = sineHeading;
+  constants.tanU = tanU;
+  constants.cosineU = cosineU;
+  constants.sineU = sineU;
+  constants.sigma = sigma;
+  constants.sineAlpha = sineAlpha;
+  constants.sineSquaredAlpha = sineSquaredAlpha;
+  constants.cosineSquaredAlpha = cosineSquaredAlpha;
+  constants.cosineAlpha = cosineAlpha;
+  constants.u2Over4 = u2Over4;
+  constants.u4Over16 = u4Over16;
+  constants.u6Over64 = u6Over64;
+  constants.u8Over256 = u8Over256;
+  constants.a0 = a0;
+  constants.a1 = a1;
+  constants.a2 = a2;
+  constants.a3 = a3;
+  constants.distanceRatio = distanceRatio;
+}
+function computeC(f, cosineSquaredAlpha) {
+  return f * cosineSquaredAlpha * (4 + f * (4 - 3 * cosineSquaredAlpha)) / 16;
+}
+function computeDeltaLambda(f, sineAlpha, cosineSquaredAlpha, sigma, sineSigma, cosineSigma, cosineTwiceSigmaMidpoint) {
+  const C = computeC(f, cosineSquaredAlpha);
+  return (1 - C) * f * sineAlpha * (sigma + C * sineSigma * (cosineTwiceSigmaMidpoint + C * cosineSigma * (2 * cosineTwiceSigmaMidpoint * cosineTwiceSigmaMidpoint - 1)));
+}
+function vincentyInverseFormula(ellipsoidGeodesic, major, minor, firstLongitude, firstLatitude, secondLongitude, secondLatitude) {
+  const eff = (major - minor) / major;
+  const l = secondLongitude - firstLongitude;
+  const u1 = Math.atan((1 - eff) * Math.tan(firstLatitude));
+  const u2 = Math.atan((1 - eff) * Math.tan(secondLatitude));
+  const cosineU1 = Math.cos(u1);
+  const sineU1 = Math.sin(u1);
+  const cosineU2 = Math.cos(u2);
+  const sineU2 = Math.sin(u2);
+  const cc = cosineU1 * cosineU2;
+  const cs = cosineU1 * sineU2;
+  const ss = sineU1 * sineU2;
+  const sc = sineU1 * cosineU2;
+  let lambda = l;
+  let lambdaDot = Math_default.TWO_PI;
+  let cosineLambda = Math.cos(lambda);
+  let sineLambda = Math.sin(lambda);
+  let sigma;
+  let cosineSigma;
+  let sineSigma;
+  let cosineSquaredAlpha;
+  let cosineTwiceSigmaMidpoint;
+  do {
+    cosineLambda = Math.cos(lambda);
+    sineLambda = Math.sin(lambda);
+    const temp = cs - sc * cosineLambda;
+    sineSigma = Math.sqrt(
+      cosineU2 * cosineU2 * sineLambda * sineLambda + temp * temp
+    );
+    cosineSigma = ss + cc * cosineLambda;
+    sigma = Math.atan2(sineSigma, cosineSigma);
+    let sineAlpha;
+    if (sineSigma === 0) {
+      sineAlpha = 0;
+      cosineSquaredAlpha = 1;
+    } else {
+      sineAlpha = cc * sineLambda / sineSigma;
+      cosineSquaredAlpha = 1 - sineAlpha * sineAlpha;
+    }
+    lambdaDot = lambda;
+    cosineTwiceSigmaMidpoint = cosineSigma - 2 * ss / cosineSquaredAlpha;
+    if (!isFinite(cosineTwiceSigmaMidpoint)) {
+      cosineTwiceSigmaMidpoint = 0;
+    }
+    lambda = l + computeDeltaLambda(
+      eff,
+      sineAlpha,
+      cosineSquaredAlpha,
+      sigma,
+      sineSigma,
+      cosineSigma,
+      cosineTwiceSigmaMidpoint
+    );
+  } while (Math.abs(lambda - lambdaDot) > Math_default.EPSILON12);
+  const uSquared = cosineSquaredAlpha * (major * major - minor * minor) / (minor * minor);
+  const A = 1 + uSquared * (4096 + uSquared * (uSquared * (320 - 175 * uSquared) - 768)) / 16384;
+  const B = uSquared * (256 + uSquared * (uSquared * (74 - 47 * uSquared) - 128)) / 1024;
+  const cosineSquaredTwiceSigmaMidpoint = cosineTwiceSigmaMidpoint * cosineTwiceSigmaMidpoint;
+  const deltaSigma = B * sineSigma * (cosineTwiceSigmaMidpoint + B * (cosineSigma * (2 * cosineSquaredTwiceSigmaMidpoint - 1) - B * cosineTwiceSigmaMidpoint * (4 * sineSigma * sineSigma - 3) * (4 * cosineSquaredTwiceSigmaMidpoint - 3) / 6) / 4);
+  const distance = minor * A * (sigma - deltaSigma);
+  const startHeading = Math.atan2(
+    cosineU2 * sineLambda,
+    cs - sc * cosineLambda
+  );
+  const endHeading = Math.atan2(cosineU1 * sineLambda, cs * cosineLambda - sc);
+  ellipsoidGeodesic._distance = distance;
+  ellipsoidGeodesic._startHeading = startHeading;
+  ellipsoidGeodesic._endHeading = endHeading;
+  ellipsoidGeodesic._uSquared = uSquared;
+}
+var scratchCart1 = new Cartesian3_default();
+var scratchCart2 = new Cartesian3_default();
+function computeProperties(ellipsoidGeodesic, start, end, ellipsoid) {
+  const firstCartesian = Cartesian3_default.normalize(
+    ellipsoid.cartographicToCartesian(start, scratchCart2),
+    scratchCart1
+  );
+  const lastCartesian = Cartesian3_default.normalize(
+    ellipsoid.cartographicToCartesian(end, scratchCart2),
+    scratchCart2
+  );
+  Check_default.typeOf.number.greaterThanOrEquals(
+    "value",
+    Math.abs(
+      Math.abs(Cartesian3_default.angleBetween(firstCartesian, lastCartesian)) - Math.PI
+    ),
+    0.0125
+  );
+  vincentyInverseFormula(
+    ellipsoidGeodesic,
+    ellipsoid.maximumRadius,
+    ellipsoid.minimumRadius,
+    start.longitude,
+    start.latitude,
+    end.longitude,
+    end.latitude
+  );
+  ellipsoidGeodesic._start = Cartographic_default.clone(
+    start,
+    ellipsoidGeodesic._start
+  );
+  ellipsoidGeodesic._end = Cartographic_default.clone(end, ellipsoidGeodesic._end);
+  ellipsoidGeodesic._start.height = 0;
+  ellipsoidGeodesic._end.height = 0;
+  setConstants(ellipsoidGeodesic);
+}
+function EllipsoidGeodesic(start, end, ellipsoid) {
+  const e = defaultValue_default(ellipsoid, Ellipsoid_default.default);
+  this._ellipsoid = e;
+  this._start = new Cartographic_default();
+  this._end = new Cartographic_default();
+  this._constants = {};
+  this._startHeading = void 0;
+  this._endHeading = void 0;
+  this._distance = void 0;
+  this._uSquared = void 0;
+  if (defined_default(start) && defined_default(end)) {
+    computeProperties(this, start, end, e);
+  }
+}
+Object.defineProperties(EllipsoidGeodesic.prototype, {
+  /**
+   * Gets the ellipsoid.
+   * @memberof EllipsoidGeodesic.prototype
+   * @type {Ellipsoid}
+   * @readonly
+   */
+  ellipsoid: {
+    get: function() {
+      return this._ellipsoid;
+    }
+  },
+  /**
+   * Gets the surface distance between the start and end point
+   * @memberof EllipsoidGeodesic.prototype
+   * @type {number}
+   * @readonly
+   */
+  surfaceDistance: {
+    get: function() {
+      Check_default.defined("distance", this._distance);
+      return this._distance;
+    }
+  },
+  /**
+   * Gets the initial planetodetic point on the path.
+   * @memberof EllipsoidGeodesic.prototype
+   * @type {Cartographic}
+   * @readonly
+   */
+  start: {
+    get: function() {
+      return this._start;
+    }
+  },
+  /**
+   * Gets the final planetodetic point on the path.
+   * @memberof EllipsoidGeodesic.prototype
+   * @type {Cartographic}
+   * @readonly
+   */
+  end: {
+    get: function() {
+      return this._end;
+    }
+  },
+  /**
+   * Gets the heading at the initial point.
+   * @memberof EllipsoidGeodesic.prototype
+   * @type {number}
+   * @readonly
+   */
+  startHeading: {
+    get: function() {
+      Check_default.defined("distance", this._distance);
+      return this._startHeading;
+    }
+  },
+  /**
+   * Gets the heading at the final point.
+   * @memberof EllipsoidGeodesic.prototype
+   * @type {number}
+   * @readonly
+   */
+  endHeading: {
+    get: function() {
+      Check_default.defined("distance", this._distance);
+      return this._endHeading;
+    }
+  }
+});
+EllipsoidGeodesic.prototype.setEndPoints = function(start, end) {
+  Check_default.defined("start", start);
+  Check_default.defined("end", end);
+  computeProperties(this, start, end, this._ellipsoid);
+};
+EllipsoidGeodesic.prototype.interpolateUsingFraction = function(fraction, result) {
+  return this.interpolateUsingSurfaceDistance(
+    this._distance * fraction,
+    result
+  );
+};
+EllipsoidGeodesic.prototype.interpolateUsingSurfaceDistance = function(distance, result) {
+  Check_default.defined("distance", this._distance);
+  const constants = this._constants;
+  const s = constants.distanceRatio + distance / constants.b;
+  const cosine2S = Math.cos(2 * s);
+  const cosine4S = Math.cos(4 * s);
+  const cosine6S = Math.cos(6 * s);
+  const sine2S = Math.sin(2 * s);
+  const sine4S = Math.sin(4 * s);
+  const sine6S = Math.sin(6 * s);
+  const sine8S = Math.sin(8 * s);
+  const s2 = s * s;
+  const s3 = s * s2;
+  const u8Over256 = constants.u8Over256;
+  const u2Over4 = constants.u2Over4;
+  const u6Over64 = constants.u6Over64;
+  const u4Over16 = constants.u4Over16;
+  let sigma = 2 * s3 * u8Over256 * cosine2S / 3 + s * (1 - u2Over4 + 7 * u4Over16 / 4 - 15 * u6Over64 / 4 + 579 * u8Over256 / 64 - (u4Over16 - 15 * u6Over64 / 4 + 187 * u8Over256 / 16) * cosine2S - (5 * u6Over64 / 4 - 115 * u8Over256 / 16) * cosine4S - 29 * u8Over256 * cosine6S / 16) + (u2Over4 / 2 - u4Over16 + 71 * u6Over64 / 32 - 85 * u8Over256 / 16) * sine2S + (5 * u4Over16 / 16 - 5 * u6Over64 / 4 + 383 * u8Over256 / 96) * sine4S - s2 * ((u6Over64 - 11 * u8Over256 / 2) * sine2S + 5 * u8Over256 * sine4S / 2) + (29 * u6Over64 / 96 - 29 * u8Over256 / 16) * sine6S + 539 * u8Over256 * sine8S / 1536;
+  const theta = Math.asin(Math.sin(sigma) * constants.cosineAlpha);
+  const latitude = Math.atan(constants.a / constants.b * Math.tan(theta));
+  sigma = sigma - constants.sigma;
+  const cosineTwiceSigmaMidpoint = Math.cos(2 * constants.sigma + sigma);
+  const sineSigma = Math.sin(sigma);
+  const cosineSigma = Math.cos(sigma);
+  const cc = constants.cosineU * cosineSigma;
+  const ss = constants.sineU * sineSigma;
+  const lambda = Math.atan2(
+    sineSigma * constants.sineHeading,
+    cc - ss * constants.cosineHeading
+  );
+  const l = lambda - computeDeltaLambda(
+    constants.f,
+    constants.sineAlpha,
+    constants.cosineSquaredAlpha,
+    sigma,
+    sineSigma,
+    cosineSigma,
+    cosineTwiceSigmaMidpoint
+  );
+  if (defined_default(result)) {
+    result.longitude = this._start.longitude + l;
+    result.latitude = latitude;
+    result.height = 0;
+    return result;
+  }
+  return new Cartographic_default(this._start.longitude + l, latitude, 0);
+};
+var EllipsoidGeodesic_default = EllipsoidGeodesic;
+
+export {
+  EllipsoidGeodesic_default
+};

public/assets/cesium/Workers/chunk-C4WPMOKT.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import {
+  WebGLConstants_default
+} from "./chunk-3HQMMUPU.js";
+import {
+  DeveloperError_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/IndexDatatype.js
+var IndexDatatype = {
+  /**
+   * 8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
+   * of an element in <code>Uint8Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_BYTE: WebGLConstants_default.UNSIGNED_BYTE,
+  /**
+   * 16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
+   * of an element in <code>Uint16Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_SHORT: WebGLConstants_default.UNSIGNED_SHORT,
+  /**
+   * 32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
+   * of an element in <code>Uint32Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_INT: WebGLConstants_default.UNSIGNED_INT
+};
+IndexDatatype.getSizeInBytes = function(indexDatatype) {
+  switch (indexDatatype) {
+    case IndexDatatype.UNSIGNED_BYTE:
+      return Uint8Array.BYTES_PER_ELEMENT;
+    case IndexDatatype.UNSIGNED_SHORT:
+      return Uint16Array.BYTES_PER_ELEMENT;
+    case IndexDatatype.UNSIGNED_INT:
+      return Uint32Array.BYTES_PER_ELEMENT;
+  }
+  throw new DeveloperError_default(
+    "indexDatatype is required and must be a valid IndexDatatype constant."
+  );
+};
+IndexDatatype.fromSizeInBytes = function(sizeInBytes) {
+  switch (sizeInBytes) {
+    case 2:
+      return IndexDatatype.UNSIGNED_SHORT;
+    case 4:
+      return IndexDatatype.UNSIGNED_INT;
+    case 1:
+      return IndexDatatype.UNSIGNED_BYTE;
+    //>>includeStart('debug', pragmas.debug);
+    default:
+      throw new DeveloperError_default(
+        "Size in bytes cannot be mapped to an IndexDatatype"
+      );
+  }
+};
+IndexDatatype.validate = function(indexDatatype) {
+  return defined_default(indexDatatype) && (indexDatatype === IndexDatatype.UNSIGNED_BYTE || indexDatatype === IndexDatatype.UNSIGNED_SHORT || indexDatatype === IndexDatatype.UNSIGNED_INT);
+};
+IndexDatatype.createTypedArray = function(numberOfVertices, indicesLengthOrArray) {
+  if (!defined_default(numberOfVertices)) {
+    throw new DeveloperError_default("numberOfVertices is required.");
+  }
+  if (numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
+    return new Uint32Array(indicesLengthOrArray);
+  }
+  return new Uint16Array(indicesLengthOrArray);
+};
+IndexDatatype.createTypedArrayFromArrayBuffer = function(numberOfVertices, sourceArray, byteOffset, length) {
+  if (!defined_default(numberOfVertices)) {
+    throw new DeveloperError_default("numberOfVertices is required.");
+  }
+  if (!defined_default(sourceArray)) {
+    throw new DeveloperError_default("sourceArray is required.");
+  }
+  if (!defined_default(byteOffset)) {
+    throw new DeveloperError_default("byteOffset is required.");
+  }
+  if (numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
+    return new Uint32Array(sourceArray, byteOffset, length);
+  }
+  return new Uint16Array(sourceArray, byteOffset, length);
+};
+IndexDatatype.fromTypedArray = function(array) {
+  if (array instanceof Uint8Array) {
+    return IndexDatatype.UNSIGNED_BYTE;
+  }
+  if (array instanceof Uint16Array) {
+    return IndexDatatype.UNSIGNED_SHORT;
+  }
+  if (array instanceof Uint32Array) {
+    return IndexDatatype.UNSIGNED_INT;
+  }
+  throw new DeveloperError_default(
+    "array must be a Uint8Array, Uint16Array, or Uint32Array."
+  );
+};
+var IndexDatatype_default = Object.freeze(IndexDatatype);
+
+export {
+  IndexDatatype_default
+};

public/assets/cesium/Workers/chunk-EDLRS3AW.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  Cartesian4_default,
+  Matrix4_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  Cartesian3_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/Plane.js
+function Plane(normal, distance) {
+  Check_default.typeOf.object("normal", normal);
+  if (!Math_default.equalsEpsilon(
+    Cartesian3_default.magnitude(normal),
+    1,
+    Math_default.EPSILON6
+  )) {
+    throw new DeveloperError_default("normal must be normalized.");
+  }
+  Check_default.typeOf.number("distance", distance);
+  this.normal = Cartesian3_default.clone(normal);
+  this.distance = distance;
+}
+Plane.fromPointNormal = function(point, normal, result) {
+  Check_default.typeOf.object("point", point);
+  Check_default.typeOf.object("normal", normal);
+  if (!Math_default.equalsEpsilon(
+    Cartesian3_default.magnitude(normal),
+    1,
+    Math_default.EPSILON6
+  )) {
+    throw new DeveloperError_default("normal must be normalized.");
+  }
+  const distance = -Cartesian3_default.dot(normal, point);
+  if (!defined_default(result)) {
+    return new Plane(normal, distance);
+  }
+  Cartesian3_default.clone(normal, result.normal);
+  result.distance = distance;
+  return result;
+};
+var scratchNormal = new Cartesian3_default();
+Plane.fromCartesian4 = function(coefficients, result) {
+  Check_default.typeOf.object("coefficients", coefficients);
+  const normal = Cartesian3_default.fromCartesian4(coefficients, scratchNormal);
+  const distance = coefficients.w;
+  if (!Math_default.equalsEpsilon(
+    Cartesian3_default.magnitude(normal),
+    1,
+    Math_default.EPSILON6
+  )) {
+    throw new DeveloperError_default("normal must be normalized.");
+  }
+  if (!defined_default(result)) {
+    return new Plane(normal, distance);
+  }
+  Cartesian3_default.clone(normal, result.normal);
+  result.distance = distance;
+  return result;
+};
+Plane.getPointDistance = function(plane, point) {
+  Check_default.typeOf.object("plane", plane);
+  Check_default.typeOf.object("point", point);
+  return Cartesian3_default.dot(plane.normal, point) + plane.distance;
+};
+var scratchCartesian = new Cartesian3_default();
+Plane.projectPointOntoPlane = function(plane, point, result) {
+  Check_default.typeOf.object("plane", plane);
+  Check_default.typeOf.object("point", point);
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  const pointDistance = Plane.getPointDistance(plane, point);
+  const scaledNormal = Cartesian3_default.multiplyByScalar(
+    plane.normal,
+    pointDistance,
+    scratchCartesian
+  );
+  return Cartesian3_default.subtract(point, scaledNormal, result);
+};
+var scratchInverseTranspose = new Matrix4_default();
+var scratchPlaneCartesian4 = new Cartesian4_default();
+var scratchTransformNormal = new Cartesian3_default();
+Plane.transform = function(plane, transform, result) {
+  Check_default.typeOf.object("plane", plane);
+  Check_default.typeOf.object("transform", transform);
+  const normal = plane.normal;
+  const distance = plane.distance;
+  const inverseTranspose = Matrix4_default.inverseTranspose(
+    transform,
+    scratchInverseTranspose
+  );
+  let planeAsCartesian4 = Cartesian4_default.fromElements(
+    normal.x,
+    normal.y,
+    normal.z,
+    distance,
+    scratchPlaneCartesian4
+  );
+  planeAsCartesian4 = Matrix4_default.multiplyByVector(
+    inverseTranspose,
+    planeAsCartesian4,
+    planeAsCartesian4
+  );
+  const transformedNormal = Cartesian3_default.fromCartesian4(
+    planeAsCartesian4,
+    scratchTransformNormal
+  );
+  planeAsCartesian4 = Cartesian4_default.divideByScalar(
+    planeAsCartesian4,
+    Cartesian3_default.magnitude(transformedNormal),
+    planeAsCartesian4
+  );
+  return Plane.fromCartesian4(planeAsCartesian4, result);
+};
+Plane.clone = function(plane, result) {
+  Check_default.typeOf.object("plane", plane);
+  if (!defined_default(result)) {
+    return new Plane(plane.normal, plane.distance);
+  }
+  Cartesian3_default.clone(plane.normal, result.normal);
+  result.distance = plane.distance;
+  return result;
+};
+Plane.equals = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  return left.distance === right.distance && Cartesian3_default.equals(left.normal, right.normal);
+};
+Plane.ORIGIN_XY_PLANE = Object.freeze(new Plane(Cartesian3_default.UNIT_Z, 0));
+Plane.ORIGIN_YZ_PLANE = Object.freeze(new Plane(Cartesian3_default.UNIT_X, 0));
+Plane.ORIGIN_ZX_PLANE = Object.freeze(new Plane(Cartesian3_default.UNIT_Y, 0));
+var Plane_default = Plane;
+
+export {
+  Plane_default
+};

public/assets/cesium/Workers/chunk-EJVGYGLF.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  CornerType_default,
+  PolylineVolumeGeometryLibrary_default
+} from "./chunk-3IFRSGEY.js";
+import {
+  PolylinePipeline_default
+} from "./chunk-QN6TBED4.js";
+import {
+  Quaternion_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  Cartesian3_default,
+  Matrix3_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/CorridorGeometryLibrary.js
+var CorridorGeometryLibrary = {};
+var scratch1 = new Cartesian3_default();
+var scratch2 = new Cartesian3_default();
+var scratch3 = new Cartesian3_default();
+var scratch4 = new Cartesian3_default();
+var scaleArray2 = [new Cartesian3_default(), new Cartesian3_default()];
+var cartesian1 = new Cartesian3_default();
+var cartesian2 = new Cartesian3_default();
+var cartesian3 = new Cartesian3_default();
+var cartesian4 = new Cartesian3_default();
+var cartesian5 = new Cartesian3_default();
+var cartesian6 = new Cartesian3_default();
+var cartesian7 = new Cartesian3_default();
+var cartesian8 = new Cartesian3_default();
+var cartesian9 = new Cartesian3_default();
+var cartesian10 = new Cartesian3_default();
+var quaterion = new Quaternion_default();
+var rotMatrix = new Matrix3_default();
+function computeRoundCorner(cornerPoint, startPoint, endPoint, cornerType, leftIsOutside) {
+  const angle = Cartesian3_default.angleBetween(
+    Cartesian3_default.subtract(startPoint, cornerPoint, scratch1),
+    Cartesian3_default.subtract(endPoint, cornerPoint, scratch2)
+  );
+  const granularity = cornerType === CornerType_default.BEVELED ? 1 : Math.ceil(angle / Math_default.toRadians(5)) + 1;
+  const size = granularity * 3;
+  const array = new Array(size);
+  array[size - 3] = endPoint.x;
+  array[size - 2] = endPoint.y;
+  array[size - 1] = endPoint.z;
+  let m;
+  if (leftIsOutside) {
+    m = Matrix3_default.fromQuaternion(
+      Quaternion_default.fromAxisAngle(
+        Cartesian3_default.negate(cornerPoint, scratch1),
+        angle / granularity,
+        quaterion
+      ),
+      rotMatrix
+    );
+  } else {
+    m = Matrix3_default.fromQuaternion(
+      Quaternion_default.fromAxisAngle(cornerPoint, angle / granularity, quaterion),
+      rotMatrix
+    );
+  }
+  let index = 0;
+  startPoint = Cartesian3_default.clone(startPoint, scratch1);
+  for (let i = 0; i < granularity; i++) {
+    startPoint = Matrix3_default.multiplyByVector(m, startPoint, startPoint);
+    array[index++] = startPoint.x;
+    array[index++] = startPoint.y;
+    array[index++] = startPoint.z;
+  }
+  return array;
+}
+function addEndCaps(calculatedPositions) {
+  let cornerPoint = cartesian1;
+  let startPoint = cartesian2;
+  let endPoint = cartesian3;
+  let leftEdge = calculatedPositions[1];
+  startPoint = Cartesian3_default.fromArray(
+    calculatedPositions[1],
+    leftEdge.length - 3,
+    startPoint
+  );
+  endPoint = Cartesian3_default.fromArray(calculatedPositions[0], 0, endPoint);
+  cornerPoint = Cartesian3_default.midpoint(startPoint, endPoint, cornerPoint);
+  const firstEndCap = computeRoundCorner(
+    cornerPoint,
+    startPoint,
+    endPoint,
+    CornerType_default.ROUNDED,
+    false
+  );
+  const length = calculatedPositions.length - 1;
+  const rightEdge = calculatedPositions[length - 1];
+  leftEdge = calculatedPositions[length];
+  startPoint = Cartesian3_default.fromArray(
+    rightEdge,
+    rightEdge.length - 3,
+    startPoint
+  );
+  endPoint = Cartesian3_default.fromArray(leftEdge, 0, endPoint);
+  cornerPoint = Cartesian3_default.midpoint(startPoint, endPoint, cornerPoint);
+  const lastEndCap = computeRoundCorner(
+    cornerPoint,
+    startPoint,
+    endPoint,
+    CornerType_default.ROUNDED,
+    false
+  );
+  return [firstEndCap, lastEndCap];
+}
+function computeMiteredCorner(position, leftCornerDirection, lastPoint, leftIsOutside) {
+  let cornerPoint = scratch1;
+  if (leftIsOutside) {
+    cornerPoint = Cartesian3_default.add(position, leftCornerDirection, cornerPoint);
+  } else {
+    leftCornerDirection = Cartesian3_default.negate(
+      leftCornerDirection,
+      leftCornerDirection
+    );
+    cornerPoint = Cartesian3_default.add(position, leftCornerDirection, cornerPoint);
+  }
+  return [
+    cornerPoint.x,
+    cornerPoint.y,
+    cornerPoint.z,
+    lastPoint.x,
+    lastPoint.y,
+    lastPoint.z
+  ];
+}
+function addShiftedPositions(positions, left, scalar, calculatedPositions) {
+  const rightPositions = new Array(positions.length);
+  const leftPositions = new Array(positions.length);
+  const scaledLeft = Cartesian3_default.multiplyByScalar(left, scalar, scratch1);
+  const scaledRight = Cartesian3_default.negate(scaledLeft, scratch2);
+  let rightIndex = 0;
+  let leftIndex = positions.length - 1;
+  for (let i = 0; i < positions.length; i += 3) {
+    const pos = Cartesian3_default.fromArray(positions, i, scratch3);
+    const rightPos = Cartesian3_default.add(pos, scaledRight, scratch4);
+    rightPositions[rightIndex++] = rightPos.x;
+    rightPositions[rightIndex++] = rightPos.y;
+    rightPositions[rightIndex++] = rightPos.z;
+    const leftPos = Cartesian3_default.add(pos, scaledLeft, scratch4);
+    leftPositions[leftIndex--] = leftPos.z;
+    leftPositions[leftIndex--] = leftPos.y;
+    leftPositions[leftIndex--] = leftPos.x;
+  }
+  calculatedPositions.push(rightPositions, leftPositions);
+  return calculatedPositions;
+}
+CorridorGeometryLibrary.addAttribute = function(attribute, value, front, back) {
+  const x = value.x;
+  const y = value.y;
+  const z = value.z;
+  if (defined_default(front)) {
+    attribute[front] = x;
+    attribute[front + 1] = y;
+    attribute[front + 2] = z;
+  }
+  if (defined_default(back)) {
+    attribute[back] = z;
+    attribute[back - 1] = y;
+    attribute[back - 2] = x;
+  }
+};
+var scratchForwardProjection = new Cartesian3_default();
+var scratchBackwardProjection = new Cartesian3_default();
+CorridorGeometryLibrary.computePositions = function(params) {
+  const granularity = params.granularity;
+  const positions = params.positions;
+  const ellipsoid = params.ellipsoid;
+  const width = params.width / 2;
+  const cornerType = params.cornerType;
+  const saveAttributes = params.saveAttributes;
+  let normal = cartesian1;
+  let forward = cartesian2;
+  let backward = cartesian3;
+  let left = cartesian4;
+  let cornerDirection = cartesian5;
+  let startPoint = cartesian6;
+  let previousPos = cartesian7;
+  let rightPos = cartesian8;
+  let leftPos = cartesian9;
+  let center = cartesian10;
+  let calculatedPositions = [];
+  const calculatedLefts = saveAttributes ? [] : void 0;
+  const calculatedNormals = saveAttributes ? [] : void 0;
+  let position = positions[0];
+  let nextPosition = positions[1];
+  forward = Cartesian3_default.normalize(
+    Cartesian3_default.subtract(nextPosition, position, forward),
+    forward
+  );
+  normal = ellipsoid.geodeticSurfaceNormal(position, normal);
+  left = Cartesian3_default.normalize(Cartesian3_default.cross(normal, forward, left), left);
+  if (saveAttributes) {
+    calculatedLefts.push(left.x, left.y, left.z);
+    calculatedNormals.push(normal.x, normal.y, normal.z);
+  }
+  previousPos = Cartesian3_default.clone(position, previousPos);
+  position = nextPosition;
+  backward = Cartesian3_default.negate(forward, backward);
+  let subdividedPositions;
+  const corners = [];
+  let i;
+  const length = positions.length;
+  for (i = 1; i < length - 1; i++) {
+    normal = ellipsoid.geodeticSurfaceNormal(position, normal);
+    nextPosition = positions[i + 1];
+    forward = Cartesian3_default.normalize(
+      Cartesian3_default.subtract(nextPosition, position, forward),
+      forward
+    );
+    cornerDirection = Cartesian3_default.normalize(
+      Cartesian3_default.add(forward, backward, cornerDirection),
+      cornerDirection
+    );
+    const forwardProjection = Cartesian3_default.multiplyByScalar(
+      normal,
+      Cartesian3_default.dot(forward, normal),
+      scratchForwardProjection
+    );
+    Cartesian3_default.subtract(forward, forwardProjection, forwardProjection);
+    Cartesian3_default.normalize(forwardProjection, forwardProjection);
+    const backwardProjection = Cartesian3_default.multiplyByScalar(
+      normal,
+      Cartesian3_default.dot(backward, normal),
+      scratchBackwardProjection
+    );
+    Cartesian3_default.subtract(backward, backwardProjection, backwardProjection);
+    Cartesian3_default.normalize(backwardProjection, backwardProjection);
+    const doCorner = !Math_default.equalsEpsilon(
+      Math.abs(Cartesian3_default.dot(forwardProjection, backwardProjection)),
+      1,
+      Math_default.EPSILON7
+    );
+    if (doCorner) {
+      cornerDirection = Cartesian3_default.cross(
+        cornerDirection,
+        normal,
+        cornerDirection
+      );
+      cornerDirection = Cartesian3_default.cross(
+        normal,
+        cornerDirection,
+        cornerDirection
+      );
+      cornerDirection = Cartesian3_default.normalize(cornerDirection, cornerDirection);
+      const scalar = width / Math.max(
+        0.25,
+        Cartesian3_default.magnitude(
+          Cartesian3_default.cross(cornerDirection, backward, scratch1)
+        )
+      );
+      const leftIsOutside = PolylineVolumeGeometryLibrary_default.angleIsGreaterThanPi(
+        forward,
+        backward,
+        position,
+        ellipsoid
+      );
+      cornerDirection = Cartesian3_default.multiplyByScalar(
+        cornerDirection,
+        scalar,
+        cornerDirection
+      );
+      if (leftIsOutside) {
+        rightPos = Cartesian3_default.add(position, cornerDirection, rightPos);
+        center = Cartesian3_default.add(
+          rightPos,
+          Cartesian3_default.multiplyByScalar(left, width, center),
+          center
+        );
+        leftPos = Cartesian3_default.add(
+          rightPos,
+          Cartesian3_default.multiplyByScalar(left, width * 2, leftPos),
+          leftPos
+        );
+        scaleArray2[0] = Cartesian3_default.clone(previousPos, scaleArray2[0]);
+        scaleArray2[1] = Cartesian3_default.clone(center, scaleArray2[1]);
+        subdividedPositions = PolylinePipeline_default.generateArc({
+          positions: scaleArray2,
+          granularity,
+          ellipsoid
+        });
+        calculatedPositions = addShiftedPositions(
+          subdividedPositions,
+          left,
+          width,
+          calculatedPositions
+        );
+        if (saveAttributes) {
+          calculatedLefts.push(left.x, left.y, left.z);
+          calculatedNormals.push(normal.x, normal.y, normal.z);
+        }
+        startPoint = Cartesian3_default.clone(leftPos, startPoint);
+        left = Cartesian3_default.normalize(
+          Cartesian3_default.cross(normal, forward, left),
+          left
+        );
+        leftPos = Cartesian3_default.add(
+          rightPos,
+          Cartesian3_default.multiplyByScalar(left, width * 2, leftPos),
+          leftPos
+        );
+        previousPos = Cartesian3_default.add(
+          rightPos,
+          Cartesian3_default.multiplyByScalar(left, width, previousPos),
+          previousPos
+        );
+        if (cornerType === CornerType_default.ROUNDED || cornerType === CornerType_default.BEVELED) {
+          corners.push({
+            leftPositions: computeRoundCorner(
+              rightPos,
+              startPoint,
+              leftPos,
+              cornerType,
+              leftIsOutside
+            )
+          });
+        } else {
+          corners.push({
+            leftPositions: computeMiteredCorner(
+              position,
+              Cartesian3_default.negate(cornerDirection, cornerDirection),
+              leftPos,
+              leftIsOutside
+            )
+          });
+        }
+      } else {
+        leftPos = Cartesian3_default.add(position, cornerDirection, leftPos);
+        center = Cartesian3_default.add(
+          leftPos,
+          Cartesian3_default.negate(
+            Cartesian3_default.multiplyByScalar(left, width, center),
+            center
+          ),
+          center
+        );
+        rightPos = Cartesian3_default.add(
+          leftPos,
+          Cartesian3_default.negate(
+            Cartesian3_default.multiplyByScalar(left, width * 2, rightPos),
+            rightPos
+          ),
+          rightPos
+        );
+        scaleArray2[0] = Cartesian3_default.clone(previousPos, scaleArray2[0]);
+        scaleArray2[1] = Cartesian3_default.clone(center, scaleArray2[1]);
+        subdividedPositions = PolylinePipeline_default.generateArc({
+          positions: scaleArray2,
+          granularity,
+          ellipsoid
+        });
+        calculatedPositions = addShiftedPositions(
+          subdividedPositions,
+          left,
+          width,
+          calculatedPositions
+        );
+        if (saveAttributes) {
+          calculatedLefts.push(left.x, left.y, left.z);
+          calculatedNormals.push(normal.x, normal.y, normal.z);
+        }
+        startPoint = Cartesian3_default.clone(rightPos, startPoint);
+        left = Cartesian3_default.normalize(
+          Cartesian3_default.cross(normal, forward, left),
+          left
+        );
+        rightPos = Cartesian3_default.add(
+          leftPos,
+          Cartesian3_default.negate(
+            Cartesian3_default.multiplyByScalar(left, width * 2, rightPos),
+            rightPos
+          ),
+          rightPos
+        );
+        previousPos = Cartesian3_default.add(
+          leftPos,
+          Cartesian3_default.negate(
+            Cartesian3_default.multiplyByScalar(left, width, previousPos),
+            previousPos
+          ),
+          previousPos
+        );
+        if (cornerType === CornerType_default.ROUNDED || cornerType === CornerType_default.BEVELED) {
+          corners.push({
+            rightPositions: computeRoundCorner(
+              leftPos,
+              startPoint,
+              rightPos,
+              cornerType,
+              leftIsOutside
+            )
+          });
+        } else {
+          corners.push({
+            rightPositions: computeMiteredCorner(
+              position,
+              cornerDirection,
+              rightPos,
+              leftIsOutside
+            )
+          });
+        }
+      }
+      backward = Cartesian3_default.negate(forward, backward);
+    }
+    position = nextPosition;
+  }
+  normal = ellipsoid.geodeticSurfaceNormal(position, normal);
+  scaleArray2[0] = Cartesian3_default.clone(previousPos, scaleArray2[0]);
+  scaleArray2[1] = Cartesian3_default.clone(position, scaleArray2[1]);
+  subdividedPositions = PolylinePipeline_default.generateArc({
+    positions: scaleArray2,
+    granularity,
+    ellipsoid
+  });
+  calculatedPositions = addShiftedPositions(
+    subdividedPositions,
+    left,
+    width,
+    calculatedPositions
+  );
+  if (saveAttributes) {
+    calculatedLefts.push(left.x, left.y, left.z);
+    calculatedNormals.push(normal.x, normal.y, normal.z);
+  }
+  let endPositions;
+  if (cornerType === CornerType_default.ROUNDED) {
+    endPositions = addEndCaps(calculatedPositions);
+  }
+  return {
+    positions: calculatedPositions,
+    corners,
+    lefts: calculatedLefts,
+    normals: calculatedNormals,
+    endPositions
+  };
+};
+var CorridorGeometryLibrary_default = CorridorGeometryLibrary;
+
+export {
+  CorridorGeometryLibrary_default
+};

public/assets/cesium/Workers/chunk-FFLMY4TE.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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 {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import {
+  defaultValue_default
+} from "./chunk-U5HSOKPQ.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/Cartesian3.js
+function Cartesian3(x, y, z) {
+  this.x = defaultValue_default(x, 0);
+  this.y = defaultValue_default(y, 0);
+  this.z = defaultValue_default(z, 0);
+}
+Cartesian3.fromSpherical = function(spherical, result) {
+  Check_default.typeOf.object("spherical", spherical);
+  if (!defined_default(result)) {
+    result = new Cartesian3();
+  }
+  const clock = spherical.clock;
+  const cone = spherical.cone;
+  const magnitude = defaultValue_default(spherical.magnitude, 1);
+  const radial = magnitude * Math.sin(cone);
+  result.x = radial * Math.cos(clock);
+  result.y = radial * Math.sin(clock);
+  result.z = magnitude * Math.cos(cone);
+  return result;
+};
+Cartesian3.fromElements = function(x, y, z, result) {
+  if (!defined_default(result)) {
+    return new Cartesian3(x, y, z);
+  }
+  result.x = x;
+  result.y = y;
+  result.z = z;
+  return result;
+};
+Cartesian3.clone = function(cartesian, result) {
+  if (!defined_default(cartesian)) {
+    return void 0;
+  }
+  if (!defined_default(result)) {
+    return new Cartesian3(cartesian.x, cartesian.y, cartesian.z);
+  }
+  result.x = cartesian.x;
+  result.y = cartesian.y;
+  result.z = cartesian.z;
+  return result;
+};
+Cartesian3.fromCartesian4 = Cartesian3.clone;
+Cartesian3.packedLength = 3;
+Cartesian3.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;
+  array[startingIndex] = value.z;
+  return array;
+};
+Cartesian3.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  if (!defined_default(result)) {
+    result = new Cartesian3();
+  }
+  result.x = array[startingIndex++];
+  result.y = array[startingIndex++];
+  result.z = array[startingIndex];
+  return result;
+};
+Cartesian3.packArray = function(array, result) {
+  Check_default.defined("array", array);
+  const length = array.length;
+  const resultLength = length * 3;
+  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 * 3 elements"
+    );
+  } else if (result.length !== resultLength) {
+    result.length = resultLength;
+  }
+  for (let i = 0; i < length; ++i) {
+    Cartesian3.pack(array[i], result, i * 3);
+  }
+  return result;
+};
+Cartesian3.unpackArray = function(array, result) {
+  Check_default.defined("array", array);
+  Check_default.typeOf.number.greaterThanOrEquals("array.length", array.length, 3);
+  if (array.length % 3 !== 0) {
+    throw new DeveloperError_default("array length must be a multiple of 3.");
+  }
+  const length = array.length;
+  if (!defined_default(result)) {
+    result = new Array(length / 3);
+  } else {
+    result.length = length / 3;
+  }
+  for (let i = 0; i < length; i += 3) {
+    const index = i / 3;
+    result[index] = Cartesian3.unpack(array, i, result[index]);
+  }
+  return result;
+};
+Cartesian3.fromArray = Cartesian3.unpack;
+Cartesian3.maximumComponent = function(cartesian) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  return Math.max(cartesian.x, cartesian.y, cartesian.z);
+};
+Cartesian3.minimumComponent = function(cartesian) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  return Math.min(cartesian.x, cartesian.y, cartesian.z);
+};
+Cartesian3.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);
+  result.z = Math.min(first.z, second.z);
+  return result;
+};
+Cartesian3.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);
+  result.z = Math.max(first.z, second.z);
+  return result;
+};
+Cartesian3.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);
+  const z = Math_default.clamp(value.z, min.z, max.z);
+  result.x = x;
+  result.y = y;
+  result.z = z;
+  return result;
+};
+Cartesian3.magnitudeSquared = function(cartesian) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  return cartesian.x * cartesian.x + cartesian.y * cartesian.y + cartesian.z * cartesian.z;
+};
+Cartesian3.magnitude = function(cartesian) {
+  return Math.sqrt(Cartesian3.magnitudeSquared(cartesian));
+};
+var distanceScratch = new Cartesian3();
+Cartesian3.distance = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Cartesian3.subtract(left, right, distanceScratch);
+  return Cartesian3.magnitude(distanceScratch);
+};
+Cartesian3.distanceSquared = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Cartesian3.subtract(left, right, distanceScratch);
+  return Cartesian3.magnitudeSquared(distanceScratch);
+};
+Cartesian3.normalize = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  const magnitude = Cartesian3.magnitude(cartesian);
+  result.x = cartesian.x / magnitude;
+  result.y = cartesian.y / magnitude;
+  result.z = cartesian.z / magnitude;
+  if (isNaN(result.x) || isNaN(result.y) || isNaN(result.z)) {
+    throw new DeveloperError_default("normalized result is not a number");
+  }
+  return result;
+};
+Cartesian3.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 + left.z * right.z;
+};
+Cartesian3.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;
+  result.z = left.z * right.z;
+  return result;
+};
+Cartesian3.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;
+  result.z = left.z / right.z;
+  return result;
+};
+Cartesian3.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;
+  result.z = left.z + right.z;
+  return result;
+};
+Cartesian3.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;
+  result.z = left.z - right.z;
+  return result;
+};
+Cartesian3.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;
+  result.z = cartesian.z * scalar;
+  return result;
+};
+Cartesian3.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;
+  result.z = cartesian.z / scalar;
+  return result;
+};
+Cartesian3.negate = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  result.x = -cartesian.x;
+  result.y = -cartesian.y;
+  result.z = -cartesian.z;
+  return result;
+};
+Cartesian3.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);
+  result.z = Math.abs(cartesian.z);
+  return result;
+};
+var lerpScratch = new Cartesian3();
+Cartesian3.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);
+  Cartesian3.multiplyByScalar(end, t, lerpScratch);
+  result = Cartesian3.multiplyByScalar(start, 1 - t, result);
+  return Cartesian3.add(lerpScratch, result, result);
+};
+var angleBetweenScratch = new Cartesian3();
+var angleBetweenScratch2 = new Cartesian3();
+Cartesian3.angleBetween = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Cartesian3.normalize(left, angleBetweenScratch);
+  Cartesian3.normalize(right, angleBetweenScratch2);
+  const cosine = Cartesian3.dot(angleBetweenScratch, angleBetweenScratch2);
+  const sine = Cartesian3.magnitude(
+    Cartesian3.cross(
+      angleBetweenScratch,
+      angleBetweenScratch2,
+      angleBetweenScratch
+    )
+  );
+  return Math.atan2(sine, cosine);
+};
+var mostOrthogonalAxisScratch = new Cartesian3();
+Cartesian3.mostOrthogonalAxis = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  const f = Cartesian3.normalize(cartesian, mostOrthogonalAxisScratch);
+  Cartesian3.abs(f, f);
+  if (f.x <= f.y) {
+    if (f.x <= f.z) {
+      result = Cartesian3.clone(Cartesian3.UNIT_X, result);
+    } else {
+      result = Cartesian3.clone(Cartesian3.UNIT_Z, result);
+    }
+  } else if (f.y <= f.z) {
+    result = Cartesian3.clone(Cartesian3.UNIT_Y, result);
+  } else {
+    result = Cartesian3.clone(Cartesian3.UNIT_Z, result);
+  }
+  return result;
+};
+Cartesian3.projectVector = function(a, b, result) {
+  Check_default.defined("a", a);
+  Check_default.defined("b", b);
+  Check_default.defined("result", result);
+  const scalar = Cartesian3.dot(a, b) / Cartesian3.dot(b, b);
+  return Cartesian3.multiplyByScalar(b, scalar, result);
+};
+Cartesian3.equals = function(left, right) {
+  return left === right || defined_default(left) && defined_default(right) && left.x === right.x && left.y === right.y && left.z === right.z;
+};
+Cartesian3.equalsArray = function(cartesian, array, offset) {
+  return cartesian.x === array[offset] && cartesian.y === array[offset + 1] && cartesian.z === array[offset + 2];
+};
+Cartesian3.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
+  ) && Math_default.equalsEpsilon(
+    left.z,
+    right.z,
+    relativeEpsilon,
+    absoluteEpsilon
+  );
+};
+Cartesian3.cross = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Check_default.typeOf.object("result", result);
+  const leftX = left.x;
+  const leftY = left.y;
+  const leftZ = left.z;
+  const rightX = right.x;
+  const rightY = right.y;
+  const rightZ = right.z;
+  const x = leftY * rightZ - leftZ * rightY;
+  const y = leftZ * rightX - leftX * rightZ;
+  const z = leftX * rightY - leftY * rightX;
+  result.x = x;
+  result.y = y;
+  result.z = z;
+  return result;
+};
+Cartesian3.midpoint = 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) * 0.5;
+  result.y = (left.y + right.y) * 0.5;
+  result.z = (left.z + right.z) * 0.5;
+  return result;
+};
+Cartesian3.fromDegrees = function(longitude, latitude, height, ellipsoid, result) {
+  Check_default.typeOf.number("longitude", longitude);
+  Check_default.typeOf.number("latitude", latitude);
+  longitude = Math_default.toRadians(longitude);
+  latitude = Math_default.toRadians(latitude);
+  return Cartesian3.fromRadians(longitude, latitude, height, ellipsoid, result);
+};
+var scratchN = new Cartesian3();
+var scratchK = new Cartesian3();
+Cartesian3._ellipsoidRadiiSquared = new Cartesian3(
+  6378137 * 6378137,
+  6378137 * 6378137,
+  6356752314245179e-9 * 6356752314245179e-9
+);
+Cartesian3.fromRadians = function(longitude, latitude, height, ellipsoid, result) {
+  Check_default.typeOf.number("longitude", longitude);
+  Check_default.typeOf.number("latitude", latitude);
+  height = defaultValue_default(height, 0);
+  const radiiSquared = !defined_default(ellipsoid) ? Cartesian3._ellipsoidRadiiSquared : ellipsoid.radiiSquared;
+  const cosLatitude = Math.cos(latitude);
+  scratchN.x = cosLatitude * Math.cos(longitude);
+  scratchN.y = cosLatitude * Math.sin(longitude);
+  scratchN.z = Math.sin(latitude);
+  scratchN = Cartesian3.normalize(scratchN, scratchN);
+  Cartesian3.multiplyComponents(radiiSquared, scratchN, scratchK);
+  const gamma = Math.sqrt(Cartesian3.dot(scratchN, scratchK));
+  scratchK = Cartesian3.divideByScalar(scratchK, gamma, scratchK);
+  scratchN = Cartesian3.multiplyByScalar(scratchN, height, scratchN);
+  if (!defined_default(result)) {
+    result = new Cartesian3();
+  }
+  return Cartesian3.add(scratchK, scratchN, result);
+};
+Cartesian3.fromDegreesArray = function(coordinates, ellipsoid, result) {
+  Check_default.defined("coordinates", coordinates);
+  if (coordinates.length < 2 || coordinates.length % 2 !== 0) {
+    throw new DeveloperError_default(
+      "the number of coordinates must be a multiple of 2 and at least 2"
+    );
+  }
+  const length = coordinates.length;
+  if (!defined_default(result)) {
+    result = new Array(length / 2);
+  } else {
+    result.length = length / 2;
+  }
+  for (let i = 0; i < length; i += 2) {
+    const longitude = coordinates[i];
+    const latitude = coordinates[i + 1];
+    const index = i / 2;
+    result[index] = Cartesian3.fromDegrees(
+      longitude,
+      latitude,
+      0,
+      ellipsoid,
+      result[index]
+    );
+  }
+  return result;
+};
+Cartesian3.fromRadiansArray = function(coordinates, ellipsoid, result) {
+  Check_default.defined("coordinates", coordinates);
+  if (coordinates.length < 2 || coordinates.length % 2 !== 0) {
+    throw new DeveloperError_default(
+      "the number of coordinates must be a multiple of 2 and at least 2"
+    );
+  }
+  const length = coordinates.length;
+  if (!defined_default(result)) {
+    result = new Array(length / 2);
+  } else {
+    result.length = length / 2;
+  }
+  for (let i = 0; i < length; i += 2) {
+    const longitude = coordinates[i];
+    const latitude = coordinates[i + 1];
+    const index = i / 2;
+    result[index] = Cartesian3.fromRadians(
+      longitude,
+      latitude,
+      0,
+      ellipsoid,
+      result[index]
+    );
+  }
+  return result;
+};
+Cartesian3.fromDegreesArrayHeights = function(coordinates, ellipsoid, result) {
+  Check_default.defined("coordinates", coordinates);
+  if (coordinates.length < 3 || coordinates.length % 3 !== 0) {
+    throw new DeveloperError_default(
+      "the number of coordinates must be a multiple of 3 and at least 3"
+    );
+  }
+  const length = coordinates.length;
+  if (!defined_default(result)) {
+    result = new Array(length / 3);
+  } else {
+    result.length = length / 3;
+  }
+  for (let i = 0; i < length; i += 3) {
+    const longitude = coordinates[i];
+    const latitude = coordinates[i + 1];
+    const height = coordinates[i + 2];
+    const index = i / 3;
+    result[index] = Cartesian3.fromDegrees(
+      longitude,
+      latitude,
+      height,
+      ellipsoid,
+      result[index]
+    );
+  }
+  return result;
+};
+Cartesian3.fromRadiansArrayHeights = function(coordinates, ellipsoid, result) {
+  Check_default.defined("coordinates", coordinates);
+  if (coordinates.length < 3 || coordinates.length % 3 !== 0) {
+    throw new DeveloperError_default(
+      "the number of coordinates must be a multiple of 3 and at least 3"
+    );
+  }
+  const length = coordinates.length;
+  if (!defined_default(result)) {
+    result = new Array(length / 3);
+  } else {
+    result.length = length / 3;
+  }
+  for (let i = 0; i < length; i += 3) {
+    const longitude = coordinates[i];
+    const latitude = coordinates[i + 1];
+    const height = coordinates[i + 2];
+    const index = i / 3;
+    result[index] = Cartesian3.fromRadians(
+      longitude,
+      latitude,
+      height,
+      ellipsoid,
+      result[index]
+    );
+  }
+  return result;
+};
+Cartesian3.ZERO = Object.freeze(new Cartesian3(0, 0, 0));
+Cartesian3.ONE = Object.freeze(new Cartesian3(1, 1, 1));
+Cartesian3.UNIT_X = Object.freeze(new Cartesian3(1, 0, 0));
+Cartesian3.UNIT_Y = Object.freeze(new Cartesian3(0, 1, 0));
+Cartesian3.UNIT_Z = Object.freeze(new Cartesian3(0, 0, 1));
+Cartesian3.prototype.clone = function(result) {
+  return Cartesian3.clone(this, result);
+};
+Cartesian3.prototype.equals = function(right) {
+  return Cartesian3.equals(this, right);
+};
+Cartesian3.prototype.equalsEpsilon = function(right, relativeEpsilon, absoluteEpsilon) {
+  return Cartesian3.equalsEpsilon(
+    this,
+    right,
+    relativeEpsilon,
+    absoluteEpsilon
+  );
+};
+Cartesian3.prototype.toString = function() {
+  return `(${this.x}, ${this.y}, ${this.z})`;
+};
+var Cartesian3_default = Cartesian3;
+
+// packages/engine/Source/Core/scaleToGeodeticSurface.js
+var scaleToGeodeticSurfaceIntersection = new Cartesian3_default();
+var scaleToGeodeticSurfaceGradient = new Cartesian3_default();
+function scaleToGeodeticSurface(cartesian, oneOverRadii, oneOverRadiiSquared, centerToleranceSquared, result) {
+  if (!defined_default(cartesian)) {
+    throw new DeveloperError_default("cartesian is required.");
+  }
+  if (!defined_default(oneOverRadii)) {
+    throw new DeveloperError_default("oneOverRadii is required.");
+  }
+  if (!defined_default(oneOverRadiiSquared)) {
+    throw new DeveloperError_default("oneOverRadiiSquared is required.");
+  }
+  if (!defined_default(centerToleranceSquared)) {
+    throw new DeveloperError_default("centerToleranceSquared is required.");
+  }
+  const positionX = cartesian.x;
+  const positionY = cartesian.y;
+  const positionZ = cartesian.z;
+  const oneOverRadiiX = oneOverRadii.x;
+  const oneOverRadiiY = oneOverRadii.y;
+  const oneOverRadiiZ = oneOverRadii.z;
+  const x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;
+  const y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;
+  const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;
+  const squaredNorm = x2 + y2 + z2;
+  const ratio = Math.sqrt(1 / squaredNorm);
+  const intersection = Cartesian3_default.multiplyByScalar(
+    cartesian,
+    ratio,
+    scaleToGeodeticSurfaceIntersection
+  );
+  if (squaredNorm < centerToleranceSquared) {
+    return !isFinite(ratio) ? void 0 : Cartesian3_default.clone(intersection, result);
+  }
+  const oneOverRadiiSquaredX = oneOverRadiiSquared.x;
+  const oneOverRadiiSquaredY = oneOverRadiiSquared.y;
+  const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
+  const gradient = scaleToGeodeticSurfaceGradient;
+  gradient.x = intersection.x * oneOverRadiiSquaredX * 2;
+  gradient.y = intersection.y * oneOverRadiiSquaredY * 2;
+  gradient.z = intersection.z * oneOverRadiiSquaredZ * 2;
+  let lambda = (1 - ratio) * Cartesian3_default.magnitude(cartesian) / (0.5 * Cartesian3_default.magnitude(gradient));
+  let correction = 0;
+  let func;
+  let denominator;
+  let xMultiplier;
+  let yMultiplier;
+  let zMultiplier;
+  let xMultiplier2;
+  let yMultiplier2;
+  let zMultiplier2;
+  let xMultiplier3;
+  let yMultiplier3;
+  let zMultiplier3;
+  do {
+    lambda -= correction;
+    xMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredX);
+    yMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredY);
+    zMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredZ);
+    xMultiplier2 = xMultiplier * xMultiplier;
+    yMultiplier2 = yMultiplier * yMultiplier;
+    zMultiplier2 = zMultiplier * zMultiplier;
+    xMultiplier3 = xMultiplier2 * xMultiplier;
+    yMultiplier3 = yMultiplier2 * yMultiplier;
+    zMultiplier3 = zMultiplier2 * zMultiplier;
+    func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1;
+    denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX + y2 * yMultiplier3 * oneOverRadiiSquaredY + z2 * zMultiplier3 * oneOverRadiiSquaredZ;
+    const derivative = -2 * denominator;
+    correction = func / derivative;
+  } while (Math.abs(func) > Math_default.EPSILON12);
+  if (!defined_default(result)) {
+    return new Cartesian3_default(
+      positionX * xMultiplier,
+      positionY * yMultiplier,
+      positionZ * zMultiplier
+    );
+  }
+  result.x = positionX * xMultiplier;
+  result.y = positionY * yMultiplier;
+  result.z = positionZ * zMultiplier;
+  return result;
+}
+var scaleToGeodeticSurface_default = scaleToGeodeticSurface;
+
+// packages/engine/Source/Core/Cartographic.js
+function Cartographic(longitude, latitude, height) {
+  this.longitude = defaultValue_default(longitude, 0);
+  this.latitude = defaultValue_default(latitude, 0);
+  this.height = defaultValue_default(height, 0);
+}
+Cartographic.fromRadians = function(longitude, latitude, height, result) {
+  Check_default.typeOf.number("longitude", longitude);
+  Check_default.typeOf.number("latitude", latitude);
+  height = defaultValue_default(height, 0);
+  if (!defined_default(result)) {
+    return new Cartographic(longitude, latitude, height);
+  }
+  result.longitude = longitude;
+  result.latitude = latitude;
+  result.height = height;
+  return result;
+};
+Cartographic.fromDegrees = function(longitude, latitude, height, result) {
+  Check_default.typeOf.number("longitude", longitude);
+  Check_default.typeOf.number("latitude", latitude);
+  longitude = Math_default.toRadians(longitude);
+  latitude = Math_default.toRadians(latitude);
+  return Cartographic.fromRadians(longitude, latitude, height, result);
+};
+var cartesianToCartographicN = new Cartesian3_default();
+var cartesianToCartographicP = new Cartesian3_default();
+var cartesianToCartographicH = new Cartesian3_default();
+Cartographic._ellipsoidOneOverRadii = new Cartesian3_default(
+  1 / 6378137,
+  1 / 6378137,
+  1 / 6356752314245179e-9
+);
+Cartographic._ellipsoidOneOverRadiiSquared = new Cartesian3_default(
+  1 / (6378137 * 6378137),
+  1 / (6378137 * 6378137),
+  1 / (6356752314245179e-9 * 6356752314245179e-9)
+);
+Cartographic._ellipsoidCenterToleranceSquared = Math_default.EPSILON1;
+Cartographic.fromCartesian = function(cartesian, ellipsoid, result) {
+  const oneOverRadii = defined_default(ellipsoid) ? ellipsoid.oneOverRadii : Cartographic._ellipsoidOneOverRadii;
+  const oneOverRadiiSquared = defined_default(ellipsoid) ? ellipsoid.oneOverRadiiSquared : Cartographic._ellipsoidOneOverRadiiSquared;
+  const centerToleranceSquared = defined_default(ellipsoid) ? ellipsoid._centerToleranceSquared : Cartographic._ellipsoidCenterToleranceSquared;
+  const p = scaleToGeodeticSurface_default(
+    cartesian,
+    oneOverRadii,
+    oneOverRadiiSquared,
+    centerToleranceSquared,
+    cartesianToCartographicP
+  );
+  if (!defined_default(p)) {
+    return void 0;
+  }
+  let n = Cartesian3_default.multiplyComponents(
+    p,
+    oneOverRadiiSquared,
+    cartesianToCartographicN
+  );
+  n = Cartesian3_default.normalize(n, n);
+  const h = Cartesian3_default.subtract(cartesian, p, cartesianToCartographicH);
+  const longitude = Math.atan2(n.y, n.x);
+  const latitude = Math.asin(n.z);
+  const height = Math_default.sign(Cartesian3_default.dot(h, cartesian)) * Cartesian3_default.magnitude(h);
+  if (!defined_default(result)) {
+    return new Cartographic(longitude, latitude, height);
+  }
+  result.longitude = longitude;
+  result.latitude = latitude;
+  result.height = height;
+  return result;
+};
+Cartographic.toCartesian = function(cartographic, ellipsoid, result) {
+  Check_default.defined("cartographic", cartographic);
+  return Cartesian3_default.fromRadians(
+    cartographic.longitude,
+    cartographic.latitude,
+    cartographic.height,
+    ellipsoid,
+    result
+  );
+};
+Cartographic.clone = function(cartographic, result) {
+  if (!defined_default(cartographic)) {
+    return void 0;
+  }
+  if (!defined_default(result)) {
+    return new Cartographic(
+      cartographic.longitude,
+      cartographic.latitude,
+      cartographic.height
+    );
+  }
+  result.longitude = cartographic.longitude;
+  result.latitude = cartographic.latitude;
+  result.height = cartographic.height;
+  return result;
+};
+Cartographic.equals = function(left, right) {
+  return left === right || defined_default(left) && defined_default(right) && left.longitude === right.longitude && left.latitude === right.latitude && left.height === right.height;
+};
+Cartographic.equalsEpsilon = function(left, right, epsilon) {
+  epsilon = defaultValue_default(epsilon, 0);
+  return left === right || defined_default(left) && defined_default(right) && Math.abs(left.longitude - right.longitude) <= epsilon && Math.abs(left.latitude - right.latitude) <= epsilon && Math.abs(left.height - right.height) <= epsilon;
+};
+Cartographic.ZERO = Object.freeze(new Cartographic(0, 0, 0));
+Cartographic.prototype.clone = function(result) {
+  return Cartographic.clone(this, result);
+};
+Cartographic.prototype.equals = function(right) {
+  return Cartographic.equals(this, right);
+};
+Cartographic.prototype.equalsEpsilon = function(right, epsilon) {
+  return Cartographic.equalsEpsilon(this, right, epsilon);
+};
+Cartographic.prototype.toString = function() {
+  return `(${this.longitude}, ${this.latitude}, ${this.height})`;
+};
+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);
+  y = defaultValue_default(y, 0);
+  z = defaultValue_default(z, 0);
+  Check_default.typeOf.number.greaterThanOrEquals("x", x, 0);
+  Check_default.typeOf.number.greaterThanOrEquals("y", y, 0);
+  Check_default.typeOf.number.greaterThanOrEquals("z", z, 0);
+  ellipsoid._radii = new Cartesian3_default(x, y, z);
+  ellipsoid._radiiSquared = new Cartesian3_default(x * x, y * y, z * z);
+  ellipsoid._radiiToTheFourth = new Cartesian3_default(
+    x * x * x * x,
+    y * y * y * y,
+    z * z * z * z
+  );
+  ellipsoid._oneOverRadii = new Cartesian3_default(
+    x === 0 ? 0 : 1 / x,
+    y === 0 ? 0 : 1 / y,
+    z === 0 ? 0 : 1 / z
+  );
+  ellipsoid._oneOverRadiiSquared = new Cartesian3_default(
+    x === 0 ? 0 : 1 / (x * x),
+    y === 0 ? 0 : 1 / (y * y),
+    z === 0 ? 0 : 1 / (z * z)
+  );
+  ellipsoid._minimumRadius = Math.min(x, y, z);
+  ellipsoid._maximumRadius = Math.max(x, y, z);
+  ellipsoid._centerToleranceSquared = Math_default.EPSILON1;
+  if (ellipsoid._radiiSquared.z !== 0) {
+    ellipsoid._squaredXOverSquaredZ = ellipsoid._radiiSquared.x / ellipsoid._radiiSquared.z;
+  }
+}
+function Ellipsoid(x, y, z) {
+  this._radii = void 0;
+  this._radiiSquared = void 0;
+  this._radiiToTheFourth = void 0;
+  this._oneOverRadii = void 0;
+  this._oneOverRadiiSquared = void 0;
+  this._minimumRadius = void 0;
+  this._maximumRadius = void 0;
+  this._centerToleranceSquared = void 0;
+  this._squaredXOverSquaredZ = void 0;
+  initialize(this, x, y, z);
+}
+Object.defineProperties(Ellipsoid.prototype, {
+  /**
+   * Gets the radii of the ellipsoid.
+   * @memberof Ellipsoid.prototype
+   * @type {Cartesian3}
+   * @readonly
+   */
+  radii: {
+    get: function() {
+      return this._radii;
+    }
+  },
+  /**
+   * Gets the squared radii of the ellipsoid.
+   * @memberof Ellipsoid.prototype
+   * @type {Cartesian3}
+   * @readonly
+   */
+  radiiSquared: {
+    get: function() {
+      return this._radiiSquared;
+    }
+  },
+  /**
+   * Gets the radii of the ellipsoid raise to the fourth power.
+   * @memberof Ellipsoid.prototype
+   * @type {Cartesian3}
+   * @readonly
+   */
+  radiiToTheFourth: {
+    get: function() {
+      return this._radiiToTheFourth;
+    }
+  },
+  /**
+   * Gets one over the radii of the ellipsoid.
+   * @memberof Ellipsoid.prototype
+   * @type {Cartesian3}
+   * @readonly
+   */
+  oneOverRadii: {
+    get: function() {
+      return this._oneOverRadii;
+    }
+  },
+  /**
+   * Gets one over the squared radii of the ellipsoid.
+   * @memberof Ellipsoid.prototype
+   * @type {Cartesian3}
+   * @readonly
+   */
+  oneOverRadiiSquared: {
+    get: function() {
+      return this._oneOverRadiiSquared;
+    }
+  },
+  /**
+   * Gets the minimum radius of the ellipsoid.
+   * @memberof Ellipsoid.prototype
+   * @type {number}
+   * @readonly
+   */
+  minimumRadius: {
+    get: function() {
+      return this._minimumRadius;
+    }
+  },
+  /**
+   * Gets the maximum radius of the ellipsoid.
+   * @memberof Ellipsoid.prototype
+   * @type {number}
+   * @readonly
+   */
+  maximumRadius: {
+    get: function() {
+      return this._maximumRadius;
+    }
+  }
+});
+Ellipsoid.clone = function(ellipsoid, result) {
+  if (!defined_default(ellipsoid)) {
+    return void 0;
+  }
+  const radii = ellipsoid._radii;
+  if (!defined_default(result)) {
+    return new Ellipsoid(radii.x, radii.y, radii.z);
+  }
+  Cartesian3_default.clone(radii, result._radii);
+  Cartesian3_default.clone(ellipsoid._radiiSquared, result._radiiSquared);
+  Cartesian3_default.clone(ellipsoid._radiiToTheFourth, result._radiiToTheFourth);
+  Cartesian3_default.clone(ellipsoid._oneOverRadii, result._oneOverRadii);
+  Cartesian3_default.clone(ellipsoid._oneOverRadiiSquared, result._oneOverRadiiSquared);
+  result._minimumRadius = ellipsoid._minimumRadius;
+  result._maximumRadius = ellipsoid._maximumRadius;
+  result._centerToleranceSquared = ellipsoid._centerToleranceSquared;
+  return result;
+};
+Ellipsoid.fromCartesian3 = function(cartesian, result) {
+  if (!defined_default(result)) {
+    result = new Ellipsoid();
+  }
+  if (!defined_default(cartesian)) {
+    return result;
+  }
+  initialize(result, cartesian.x, cartesian.y, cartesian.z);
+  return result;
+};
+Ellipsoid.WGS84 = Object.freeze(
+  new Ellipsoid(6378137, 6378137, 6356752314245179e-9)
+);
+Ellipsoid.UNIT_SPHERE = Object.freeze(new Ellipsoid(1, 1, 1));
+Ellipsoid.MOON = Object.freeze(
+  new Ellipsoid(
+    Math_default.LUNAR_RADIUS,
+    Math_default.LUNAR_RADIUS,
+    Math_default.LUNAR_RADIUS
+  )
+);
+Ellipsoid._default = Ellipsoid.WGS84;
+Object.defineProperties(Ellipsoid, {
+  /**
+   * The default ellipsoid used when not otherwise specified.
+   * @memberof Ellipsoid
+   * @type {Ellipsoid}
+   * @example
+   * Cesium.Ellipsoid.default = Cesium.Ellipsoid.MOON;
+   *
+   * // Apollo 11 landing site
+   * const position = Cesium.Cartesian3.fromRadians(
+   *   0.67416,
+   *   23.47315,
+   * );
+   */
+  default: {
+    get: function() {
+      return Ellipsoid._default;
+    },
+    set: function(value) {
+      Check_default.typeOf.object("value", value);
+      Ellipsoid._default = value;
+      Cartesian3_default._ellipsoidRadiiSquared = value.radiiSquared;
+      Cartographic_default._ellipsoidOneOverRadii = value.oneOverRadii;
+      Cartographic_default._ellipsoidOneOverRadiiSquared = value.oneOverRadiiSquared;
+      Cartographic_default._ellipsoidCenterToleranceSquared = value._centerToleranceSquared;
+    }
+  }
+});
+Ellipsoid.prototype.clone = function(result) {
+  return Ellipsoid.clone(this, result);
+};
+Ellipsoid.packedLength = Cartesian3_default.packedLength;
+Ellipsoid.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  Cartesian3_default.pack(value._radii, array, startingIndex);
+  return array;
+};
+Ellipsoid.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const radii = Cartesian3_default.unpack(array, startingIndex);
+  return Ellipsoid.fromCartesian3(radii, result);
+};
+Ellipsoid.prototype.geocentricSurfaceNormal = Cartesian3_default.normalize;
+Ellipsoid.prototype.geodeticSurfaceNormalCartographic = function(cartographic, result) {
+  Check_default.typeOf.object("cartographic", cartographic);
+  const longitude = cartographic.longitude;
+  const latitude = cartographic.latitude;
+  const cosLatitude = Math.cos(latitude);
+  const x = cosLatitude * Math.cos(longitude);
+  const y = cosLatitude * Math.sin(longitude);
+  const z = Math.sin(latitude);
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  result.x = x;
+  result.y = y;
+  result.z = z;
+  return Cartesian3_default.normalize(result, result);
+};
+Ellipsoid.prototype.geodeticSurfaceNormal = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  if (isNaN(cartesian.x) || isNaN(cartesian.y) || isNaN(cartesian.z)) {
+    throw new DeveloperError_default("cartesian has a NaN component");
+  }
+  if (Cartesian3_default.equalsEpsilon(cartesian, Cartesian3_default.ZERO, Math_default.EPSILON14)) {
+    return void 0;
+  }
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  result = Cartesian3_default.multiplyComponents(
+    cartesian,
+    this._oneOverRadiiSquared,
+    result
+  );
+  return Cartesian3_default.normalize(result, result);
+};
+var cartographicToCartesianNormal = new Cartesian3_default();
+var cartographicToCartesianK = new Cartesian3_default();
+Ellipsoid.prototype.cartographicToCartesian = function(cartographic, result) {
+  const n = cartographicToCartesianNormal;
+  const k = cartographicToCartesianK;
+  this.geodeticSurfaceNormalCartographic(cartographic, n);
+  Cartesian3_default.multiplyComponents(this._radiiSquared, n, k);
+  const gamma = Math.sqrt(Cartesian3_default.dot(n, k));
+  Cartesian3_default.divideByScalar(k, gamma, k);
+  Cartesian3_default.multiplyByScalar(n, cartographic.height, n);
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  return Cartesian3_default.add(k, n, result);
+};
+Ellipsoid.prototype.cartographicArrayToCartesianArray = function(cartographics, result) {
+  Check_default.defined("cartographics", cartographics);
+  const length = cartographics.length;
+  if (!defined_default(result)) {
+    result = new Array(length);
+  } else {
+    result.length = length;
+  }
+  for (let i = 0; i < length; i++) {
+    result[i] = this.cartographicToCartesian(cartographics[i], result[i]);
+  }
+  return result;
+};
+var cartesianToCartographicN2 = new Cartesian3_default();
+var cartesianToCartographicP2 = new Cartesian3_default();
+var cartesianToCartographicH2 = new Cartesian3_default();
+Ellipsoid.prototype.cartesianToCartographic = function(cartesian, result) {
+  const p = this.scaleToGeodeticSurface(cartesian, cartesianToCartographicP2);
+  if (!defined_default(p)) {
+    return void 0;
+  }
+  const n = this.geodeticSurfaceNormal(p, cartesianToCartographicN2);
+  const h = Cartesian3_default.subtract(cartesian, p, cartesianToCartographicH2);
+  const longitude = Math.atan2(n.y, n.x);
+  const latitude = Math.asin(n.z);
+  const height = Math_default.sign(Cartesian3_default.dot(h, cartesian)) * Cartesian3_default.magnitude(h);
+  if (!defined_default(result)) {
+    return new Cartographic_default(longitude, latitude, height);
+  }
+  result.longitude = longitude;
+  result.latitude = latitude;
+  result.height = height;
+  return result;
+};
+Ellipsoid.prototype.cartesianArrayToCartographicArray = function(cartesians, result) {
+  Check_default.defined("cartesians", cartesians);
+  const length = cartesians.length;
+  if (!defined_default(result)) {
+    result = new Array(length);
+  } else {
+    result.length = length;
+  }
+  for (let i = 0; i < length; ++i) {
+    result[i] = this.cartesianToCartographic(cartesians[i], result[i]);
+  }
+  return result;
+};
+Ellipsoid.prototype.scaleToGeodeticSurface = function(cartesian, result) {
+  return scaleToGeodeticSurface_default(
+    cartesian,
+    this._oneOverRadii,
+    this._oneOverRadiiSquared,
+    this._centerToleranceSquared,
+    result
+  );
+};
+Ellipsoid.prototype.scaleToGeocentricSurface = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  const positionX = cartesian.x;
+  const positionY = cartesian.y;
+  const positionZ = cartesian.z;
+  const oneOverRadiiSquared = this._oneOverRadiiSquared;
+  const beta = 1 / Math.sqrt(
+    positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z
+  );
+  return Cartesian3_default.multiplyByScalar(cartesian, beta, result);
+};
+Ellipsoid.prototype.transformPositionToScaledSpace = function(position, result) {
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  return Cartesian3_default.multiplyComponents(position, this._oneOverRadii, result);
+};
+Ellipsoid.prototype.transformPositionFromScaledSpace = function(position, result) {
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  return Cartesian3_default.multiplyComponents(position, this._radii, result);
+};
+Ellipsoid.prototype.equals = function(right) {
+  return this === right || defined_default(right) && Cartesian3_default.equals(this._radii, right._radii);
+};
+Ellipsoid.prototype.toString = function() {
+  return this._radii.toString();
+};
+Ellipsoid.prototype.getSurfaceNormalIntersectionWithZAxis = function(position, buffer, result) {
+  Check_default.typeOf.object("position", position);
+  if (!Math_default.equalsEpsilon(
+    this._radii.x,
+    this._radii.y,
+    Math_default.EPSILON15
+  )) {
+    throw new DeveloperError_default(
+      "Ellipsoid must be an ellipsoid of revolution (radii.x == radii.y)"
+    );
+  }
+  Check_default.typeOf.number.greaterThan("Ellipsoid.radii.z", this._radii.z, 0);
+  buffer = defaultValue_default(buffer, 0);
+  const squaredXOverSquaredZ = this._squaredXOverSquaredZ;
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  result.x = 0;
+  result.y = 0;
+  result.z = position.z * (1 - squaredXOverSquaredZ);
+  if (Math.abs(result.z) >= this._radii.z - buffer) {
+    return void 0;
+  }
+  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,
+  0.67940956829902,
+  0.86506336668898,
+  0.97390652851717,
+  0
+];
+var weights = [
+  0.29552422471475,
+  0.26926671930999,
+  0.21908636251598,
+  0.14945134915058,
+  0.066671344308684,
+  0
+];
+function gaussLegendreQuadrature(a, b, func) {
+  Check_default.typeOf.number("a", a);
+  Check_default.typeOf.number("b", b);
+  Check_default.typeOf.func("func", func);
+  const xMean = 0.5 * (b + a);
+  const xRange = 0.5 * (b - a);
+  let sum = 0;
+  for (let i = 0; i < 5; i++) {
+    const dx = xRange * abscissas[i];
+    sum += weights[i] * (func(xMean + dx) + func(xMean - dx));
+  }
+  sum *= xRange;
+  return sum;
+}
+Ellipsoid.prototype.surfaceArea = function(rectangle) {
+  Check_default.typeOf.object("rectangle", rectangle);
+  const minLongitude = rectangle.west;
+  let maxLongitude = rectangle.east;
+  const minLatitude = rectangle.south;
+  const maxLatitude = rectangle.north;
+  while (maxLongitude < minLongitude) {
+    maxLongitude += Math_default.TWO_PI;
+  }
+  const radiiSquared = this._radiiSquared;
+  const a2 = radiiSquared.x;
+  const b2 = radiiSquared.y;
+  const c2 = radiiSquared.z;
+  const a2b2 = a2 * b2;
+  return gaussLegendreQuadrature(minLatitude, maxLatitude, function(lat) {
+    const sinPhi = Math.cos(lat);
+    const cosPhi = Math.sin(lat);
+    return Math.cos(lat) * gaussLegendreQuadrature(minLongitude, maxLongitude, function(lon) {
+      const cosTheta = Math.cos(lon);
+      const sinTheta = Math.sin(lon);
+      return Math.sqrt(
+        a2b2 * cosPhi * cosPhi + c2 * (b2 * cosTheta * cosTheta + a2 * sinTheta * sinTheta) * sinPhi * sinPhi
+      );
+    });
+  });
+};
+var Ellipsoid_default = Ellipsoid;
+
+// packages/engine/Source/Core/Matrix3.js
+function Matrix3(column0Row0, column1Row0, column2Row0, column0Row1, column1Row1, column2Row1, column0Row2, column1Row2, column2Row2) {
+  this[0] = defaultValue_default(column0Row0, 0);
+  this[1] = defaultValue_default(column0Row1, 0);
+  this[2] = defaultValue_default(column0Row2, 0);
+  this[3] = defaultValue_default(column1Row0, 0);
+  this[4] = defaultValue_default(column1Row1, 0);
+  this[5] = defaultValue_default(column1Row2, 0);
+  this[6] = defaultValue_default(column2Row0, 0);
+  this[7] = defaultValue_default(column2Row1, 0);
+  this[8] = defaultValue_default(column2Row2, 0);
+}
+Matrix3.packedLength = 9;
+Matrix3.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  array[startingIndex++] = value[0];
+  array[startingIndex++] = value[1];
+  array[startingIndex++] = value[2];
+  array[startingIndex++] = value[3];
+  array[startingIndex++] = value[4];
+  array[startingIndex++] = value[5];
+  array[startingIndex++] = value[6];
+  array[startingIndex++] = value[7];
+  array[startingIndex++] = value[8];
+  return array;
+};
+Matrix3.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  if (!defined_default(result)) {
+    result = new Matrix3();
+  }
+  result[0] = array[startingIndex++];
+  result[1] = array[startingIndex++];
+  result[2] = array[startingIndex++];
+  result[3] = array[startingIndex++];
+  result[4] = array[startingIndex++];
+  result[5] = array[startingIndex++];
+  result[6] = array[startingIndex++];
+  result[7] = array[startingIndex++];
+  result[8] = array[startingIndex++];
+  return result;
+};
+Matrix3.packArray = function(array, result) {
+  Check_default.defined("array", array);
+  const length = array.length;
+  const resultLength = length * 9;
+  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 * 9 elements"
+    );
+  } else if (result.length !== resultLength) {
+    result.length = resultLength;
+  }
+  for (let i = 0; i < length; ++i) {
+    Matrix3.pack(array[i], result, i * 9);
+  }
+  return result;
+};
+Matrix3.unpackArray = function(array, result) {
+  Check_default.defined("array", array);
+  Check_default.typeOf.number.greaterThanOrEquals("array.length", array.length, 9);
+  if (array.length % 9 !== 0) {
+    throw new DeveloperError_default("array length must be a multiple of 9.");
+  }
+  const length = array.length;
+  if (!defined_default(result)) {
+    result = new Array(length / 9);
+  } else {
+    result.length = length / 9;
+  }
+  for (let i = 0; i < length; i += 9) {
+    const index = i / 9;
+    result[index] = Matrix3.unpack(array, i, result[index]);
+  }
+  return result;
+};
+Matrix3.clone = function(matrix, result) {
+  if (!defined_default(matrix)) {
+    return void 0;
+  }
+  if (!defined_default(result)) {
+    return new Matrix3(
+      matrix[0],
+      matrix[3],
+      matrix[6],
+      matrix[1],
+      matrix[4],
+      matrix[7],
+      matrix[2],
+      matrix[5],
+      matrix[8]
+    );
+  }
+  result[0] = matrix[0];
+  result[1] = matrix[1];
+  result[2] = matrix[2];
+  result[3] = matrix[3];
+  result[4] = matrix[4];
+  result[5] = matrix[5];
+  result[6] = matrix[6];
+  result[7] = matrix[7];
+  result[8] = matrix[8];
+  return result;
+};
+Matrix3.fromArray = Matrix3.unpack;
+Matrix3.fromColumnMajorArray = function(values, result) {
+  Check_default.defined("values", values);
+  return Matrix3.clone(values, result);
+};
+Matrix3.fromRowMajorArray = function(values, result) {
+  Check_default.defined("values", values);
+  if (!defined_default(result)) {
+    return new Matrix3(
+      values[0],
+      values[1],
+      values[2],
+      values[3],
+      values[4],
+      values[5],
+      values[6],
+      values[7],
+      values[8]
+    );
+  }
+  result[0] = values[0];
+  result[1] = values[3];
+  result[2] = values[6];
+  result[3] = values[1];
+  result[4] = values[4];
+  result[5] = values[7];
+  result[6] = values[2];
+  result[7] = values[5];
+  result[8] = values[8];
+  return result;
+};
+Matrix3.fromQuaternion = function(quaternion, result) {
+  Check_default.typeOf.object("quaternion", quaternion);
+  const x2 = quaternion.x * quaternion.x;
+  const xy = quaternion.x * quaternion.y;
+  const xz = quaternion.x * quaternion.z;
+  const xw = quaternion.x * quaternion.w;
+  const y2 = quaternion.y * quaternion.y;
+  const yz = quaternion.y * quaternion.z;
+  const yw = quaternion.y * quaternion.w;
+  const z2 = quaternion.z * quaternion.z;
+  const zw = quaternion.z * quaternion.w;
+  const w2 = quaternion.w * quaternion.w;
+  const m00 = x2 - y2 - z2 + w2;
+  const m01 = 2 * (xy - zw);
+  const m02 = 2 * (xz + yw);
+  const m10 = 2 * (xy + zw);
+  const m11 = -x2 + y2 - z2 + w2;
+  const m12 = 2 * (yz - xw);
+  const m20 = 2 * (xz - yw);
+  const m21 = 2 * (yz + xw);
+  const m22 = -x2 - y2 + z2 + w2;
+  if (!defined_default(result)) {
+    return new Matrix3(m00, m01, m02, m10, m11, m12, m20, m21, m22);
+  }
+  result[0] = m00;
+  result[1] = m10;
+  result[2] = m20;
+  result[3] = m01;
+  result[4] = m11;
+  result[5] = m21;
+  result[6] = m02;
+  result[7] = m12;
+  result[8] = m22;
+  return result;
+};
+Matrix3.fromHeadingPitchRoll = function(headingPitchRoll, result) {
+  Check_default.typeOf.object("headingPitchRoll", headingPitchRoll);
+  const cosTheta = Math.cos(-headingPitchRoll.pitch);
+  const cosPsi = Math.cos(-headingPitchRoll.heading);
+  const cosPhi = Math.cos(headingPitchRoll.roll);
+  const sinTheta = Math.sin(-headingPitchRoll.pitch);
+  const sinPsi = Math.sin(-headingPitchRoll.heading);
+  const sinPhi = Math.sin(headingPitchRoll.roll);
+  const m00 = cosTheta * cosPsi;
+  const m01 = -cosPhi * sinPsi + sinPhi * sinTheta * cosPsi;
+  const m02 = sinPhi * sinPsi + cosPhi * sinTheta * cosPsi;
+  const m10 = cosTheta * sinPsi;
+  const m11 = cosPhi * cosPsi + sinPhi * sinTheta * sinPsi;
+  const m12 = -sinPhi * cosPsi + cosPhi * sinTheta * sinPsi;
+  const m20 = -sinTheta;
+  const m21 = sinPhi * cosTheta;
+  const m22 = cosPhi * cosTheta;
+  if (!defined_default(result)) {
+    return new Matrix3(m00, m01, m02, m10, m11, m12, m20, m21, m22);
+  }
+  result[0] = m00;
+  result[1] = m10;
+  result[2] = m20;
+  result[3] = m01;
+  result[4] = m11;
+  result[5] = m21;
+  result[6] = m02;
+  result[7] = m12;
+  result[8] = m22;
+  return result;
+};
+Matrix3.fromScale = function(scale, result) {
+  Check_default.typeOf.object("scale", scale);
+  if (!defined_default(result)) {
+    return new Matrix3(scale.x, 0, 0, 0, scale.y, 0, 0, 0, scale.z);
+  }
+  result[0] = scale.x;
+  result[1] = 0;
+  result[2] = 0;
+  result[3] = 0;
+  result[4] = scale.y;
+  result[5] = 0;
+  result[6] = 0;
+  result[7] = 0;
+  result[8] = scale.z;
+  return result;
+};
+Matrix3.fromUniformScale = function(scale, result) {
+  Check_default.typeOf.number("scale", scale);
+  if (!defined_default(result)) {
+    return new Matrix3(scale, 0, 0, 0, scale, 0, 0, 0, scale);
+  }
+  result[0] = scale;
+  result[1] = 0;
+  result[2] = 0;
+  result[3] = 0;
+  result[4] = scale;
+  result[5] = 0;
+  result[6] = 0;
+  result[7] = 0;
+  result[8] = scale;
+  return result;
+};
+Matrix3.fromCrossProduct = function(vector, result) {
+  Check_default.typeOf.object("vector", vector);
+  if (!defined_default(result)) {
+    return new Matrix3(
+      0,
+      -vector.z,
+      vector.y,
+      vector.z,
+      0,
+      -vector.x,
+      -vector.y,
+      vector.x,
+      0
+    );
+  }
+  result[0] = 0;
+  result[1] = vector.z;
+  result[2] = -vector.y;
+  result[3] = -vector.z;
+  result[4] = 0;
+  result[5] = vector.x;
+  result[6] = vector.y;
+  result[7] = -vector.x;
+  result[8] = 0;
+  return result;
+};
+Matrix3.fromRotationX = function(angle, result) {
+  Check_default.typeOf.number("angle", angle);
+  const cosAngle = Math.cos(angle);
+  const sinAngle = Math.sin(angle);
+  if (!defined_default(result)) {
+    return new Matrix3(
+      1,
+      0,
+      0,
+      0,
+      cosAngle,
+      -sinAngle,
+      0,
+      sinAngle,
+      cosAngle
+    );
+  }
+  result[0] = 1;
+  result[1] = 0;
+  result[2] = 0;
+  result[3] = 0;
+  result[4] = cosAngle;
+  result[5] = sinAngle;
+  result[6] = 0;
+  result[7] = -sinAngle;
+  result[8] = cosAngle;
+  return result;
+};
+Matrix3.fromRotationY = function(angle, result) {
+  Check_default.typeOf.number("angle", angle);
+  const cosAngle = Math.cos(angle);
+  const sinAngle = Math.sin(angle);
+  if (!defined_default(result)) {
+    return new Matrix3(
+      cosAngle,
+      0,
+      sinAngle,
+      0,
+      1,
+      0,
+      -sinAngle,
+      0,
+      cosAngle
+    );
+  }
+  result[0] = cosAngle;
+  result[1] = 0;
+  result[2] = -sinAngle;
+  result[3] = 0;
+  result[4] = 1;
+  result[5] = 0;
+  result[6] = sinAngle;
+  result[7] = 0;
+  result[8] = cosAngle;
+  return result;
+};
+Matrix3.fromRotationZ = function(angle, result) {
+  Check_default.typeOf.number("angle", angle);
+  const cosAngle = Math.cos(angle);
+  const sinAngle = Math.sin(angle);
+  if (!defined_default(result)) {
+    return new Matrix3(
+      cosAngle,
+      -sinAngle,
+      0,
+      sinAngle,
+      cosAngle,
+      0,
+      0,
+      0,
+      1
+    );
+  }
+  result[0] = cosAngle;
+  result[1] = sinAngle;
+  result[2] = 0;
+  result[3] = -sinAngle;
+  result[4] = cosAngle;
+  result[5] = 0;
+  result[6] = 0;
+  result[7] = 0;
+  result[8] = 1;
+  return result;
+};
+Matrix3.toArray = function(matrix, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  if (!defined_default(result)) {
+    return [
+      matrix[0],
+      matrix[1],
+      matrix[2],
+      matrix[3],
+      matrix[4],
+      matrix[5],
+      matrix[6],
+      matrix[7],
+      matrix[8]
+    ];
+  }
+  result[0] = matrix[0];
+  result[1] = matrix[1];
+  result[2] = matrix[2];
+  result[3] = matrix[3];
+  result[4] = matrix[4];
+  result[5] = matrix[5];
+  result[6] = matrix[6];
+  result[7] = matrix[7];
+  result[8] = matrix[8];
+  return result;
+};
+Matrix3.getElementIndex = function(column, row) {
+  Check_default.typeOf.number.greaterThanOrEquals("row", row, 0);
+  Check_default.typeOf.number.lessThanOrEquals("row", row, 2);
+  Check_default.typeOf.number.greaterThanOrEquals("column", column, 0);
+  Check_default.typeOf.number.lessThanOrEquals("column", column, 2);
+  return column * 3 + row;
+};
+Matrix3.getColumn = function(matrix, index, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.number.greaterThanOrEquals("index", index, 0);
+  Check_default.typeOf.number.lessThanOrEquals("index", index, 2);
+  Check_default.typeOf.object("result", result);
+  const startIndex = index * 3;
+  const x = matrix[startIndex];
+  const y = matrix[startIndex + 1];
+  const z = matrix[startIndex + 2];
+  result.x = x;
+  result.y = y;
+  result.z = z;
+  return result;
+};
+Matrix3.setColumn = function(matrix, index, cartesian, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.number.greaterThanOrEquals("index", index, 0);
+  Check_default.typeOf.number.lessThanOrEquals("index", index, 2);
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  result = Matrix3.clone(matrix, result);
+  const startIndex = index * 3;
+  result[startIndex] = cartesian.x;
+  result[startIndex + 1] = cartesian.y;
+  result[startIndex + 2] = cartesian.z;
+  return result;
+};
+Matrix3.getRow = function(matrix, index, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.number.greaterThanOrEquals("index", index, 0);
+  Check_default.typeOf.number.lessThanOrEquals("index", index, 2);
+  Check_default.typeOf.object("result", result);
+  const x = matrix[index];
+  const y = matrix[index + 3];
+  const z = matrix[index + 6];
+  result.x = x;
+  result.y = y;
+  result.z = z;
+  return result;
+};
+Matrix3.setRow = function(matrix, index, cartesian, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.number.greaterThanOrEquals("index", index, 0);
+  Check_default.typeOf.number.lessThanOrEquals("index", index, 2);
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  result = Matrix3.clone(matrix, result);
+  result[index] = cartesian.x;
+  result[index + 3] = cartesian.y;
+  result[index + 6] = cartesian.z;
+  return result;
+};
+var scaleScratch1 = new Cartesian3_default();
+Matrix3.setScale = function(matrix, scale, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.object("scale", scale);
+  Check_default.typeOf.object("result", result);
+  const existingScale = Matrix3.getScale(matrix, scaleScratch1);
+  const scaleRatioX = scale.x / existingScale.x;
+  const scaleRatioY = scale.y / existingScale.y;
+  const scaleRatioZ = scale.z / existingScale.z;
+  result[0] = matrix[0] * scaleRatioX;
+  result[1] = matrix[1] * scaleRatioX;
+  result[2] = matrix[2] * scaleRatioX;
+  result[3] = matrix[3] * scaleRatioY;
+  result[4] = matrix[4] * scaleRatioY;
+  result[5] = matrix[5] * scaleRatioY;
+  result[6] = matrix[6] * scaleRatioZ;
+  result[7] = matrix[7] * scaleRatioZ;
+  result[8] = matrix[8] * scaleRatioZ;
+  return result;
+};
+var scaleScratch2 = new Cartesian3_default();
+Matrix3.setUniformScale = function(matrix, scale, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.number("scale", scale);
+  Check_default.typeOf.object("result", result);
+  const existingScale = Matrix3.getScale(matrix, scaleScratch2);
+  const scaleRatioX = scale / existingScale.x;
+  const scaleRatioY = scale / existingScale.y;
+  const scaleRatioZ = scale / existingScale.z;
+  result[0] = matrix[0] * scaleRatioX;
+  result[1] = matrix[1] * scaleRatioX;
+  result[2] = matrix[2] * scaleRatioX;
+  result[3] = matrix[3] * scaleRatioY;
+  result[4] = matrix[4] * scaleRatioY;
+  result[5] = matrix[5] * scaleRatioY;
+  result[6] = matrix[6] * scaleRatioZ;
+  result[7] = matrix[7] * scaleRatioZ;
+  result[8] = matrix[8] * scaleRatioZ;
+  return result;
+};
+var scratchColumn = new Cartesian3_default();
+Matrix3.getScale = function(matrix, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.object("result", result);
+  result.x = Cartesian3_default.magnitude(
+    Cartesian3_default.fromElements(matrix[0], matrix[1], matrix[2], scratchColumn)
+  );
+  result.y = Cartesian3_default.magnitude(
+    Cartesian3_default.fromElements(matrix[3], matrix[4], matrix[5], scratchColumn)
+  );
+  result.z = Cartesian3_default.magnitude(
+    Cartesian3_default.fromElements(matrix[6], matrix[7], matrix[8], scratchColumn)
+  );
+  return result;
+};
+var scaleScratch3 = new Cartesian3_default();
+Matrix3.getMaximumScale = function(matrix) {
+  Matrix3.getScale(matrix, scaleScratch3);
+  return Cartesian3_default.maximumComponent(scaleScratch3);
+};
+var scaleScratch4 = new Cartesian3_default();
+Matrix3.setRotation = function(matrix, rotation, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.object("result", result);
+  const scale = Matrix3.getScale(matrix, scaleScratch4);
+  result[0] = rotation[0] * scale.x;
+  result[1] = rotation[1] * scale.x;
+  result[2] = rotation[2] * scale.x;
+  result[3] = rotation[3] * scale.y;
+  result[4] = rotation[4] * scale.y;
+  result[5] = rotation[5] * scale.y;
+  result[6] = rotation[6] * scale.z;
+  result[7] = rotation[7] * scale.z;
+  result[8] = rotation[8] * scale.z;
+  return result;
+};
+var scaleScratch5 = new Cartesian3_default();
+Matrix3.getRotation = function(matrix, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.object("result", result);
+  const scale = Matrix3.getScale(matrix, scaleScratch5);
+  result[0] = matrix[0] / scale.x;
+  result[1] = matrix[1] / scale.x;
+  result[2] = matrix[2] / scale.x;
+  result[3] = matrix[3] / scale.y;
+  result[4] = matrix[4] / scale.y;
+  result[5] = matrix[5] / scale.y;
+  result[6] = matrix[6] / scale.z;
+  result[7] = matrix[7] / scale.z;
+  result[8] = matrix[8] / scale.z;
+  return result;
+};
+Matrix3.multiply = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Check_default.typeOf.object("result", result);
+  const column0Row0 = left[0] * right[0] + left[3] * right[1] + left[6] * right[2];
+  const column0Row1 = left[1] * right[0] + left[4] * right[1] + left[7] * right[2];
+  const column0Row2 = left[2] * right[0] + left[5] * right[1] + left[8] * right[2];
+  const column1Row0 = left[0] * right[3] + left[3] * right[4] + left[6] * right[5];
+  const column1Row1 = left[1] * right[3] + left[4] * right[4] + left[7] * right[5];
+  const column1Row2 = left[2] * right[3] + left[5] * right[4] + left[8] * right[5];
+  const column2Row0 = left[0] * right[6] + left[3] * right[7] + left[6] * right[8];
+  const column2Row1 = left[1] * right[6] + left[4] * right[7] + left[7] * right[8];
+  const column2Row2 = left[2] * right[6] + left[5] * right[7] + left[8] * right[8];
+  result[0] = column0Row0;
+  result[1] = column0Row1;
+  result[2] = column0Row2;
+  result[3] = column1Row0;
+  result[4] = column1Row1;
+  result[5] = column1Row2;
+  result[6] = column2Row0;
+  result[7] = column2Row1;
+  result[8] = column2Row2;
+  return result;
+};
+Matrix3.add = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Check_default.typeOf.object("result", result);
+  result[0] = left[0] + right[0];
+  result[1] = left[1] + right[1];
+  result[2] = left[2] + right[2];
+  result[3] = left[3] + right[3];
+  result[4] = left[4] + right[4];
+  result[5] = left[5] + right[5];
+  result[6] = left[6] + right[6];
+  result[7] = left[7] + right[7];
+  result[8] = left[8] + right[8];
+  return result;
+};
+Matrix3.subtract = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Check_default.typeOf.object("result", result);
+  result[0] = left[0] - right[0];
+  result[1] = left[1] - right[1];
+  result[2] = left[2] - right[2];
+  result[3] = left[3] - right[3];
+  result[4] = left[4] - right[4];
+  result[5] = left[5] - right[5];
+  result[6] = left[6] - right[6];
+  result[7] = left[7] - right[7];
+  result[8] = left[8] - right[8];
+  return result;
+};
+Matrix3.multiplyByVector = function(matrix, cartesian, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  const vX = cartesian.x;
+  const vY = cartesian.y;
+  const vZ = cartesian.z;
+  const x = matrix[0] * vX + matrix[3] * vY + matrix[6] * vZ;
+  const y = matrix[1] * vX + matrix[4] * vY + matrix[7] * vZ;
+  const z = matrix[2] * vX + matrix[5] * vY + matrix[8] * vZ;
+  result.x = x;
+  result.y = y;
+  result.z = z;
+  return result;
+};
+Matrix3.multiplyByScalar = function(matrix, scalar, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.number("scalar", scalar);
+  Check_default.typeOf.object("result", result);
+  result[0] = matrix[0] * scalar;
+  result[1] = matrix[1] * scalar;
+  result[2] = matrix[2] * scalar;
+  result[3] = matrix[3] * scalar;
+  result[4] = matrix[4] * scalar;
+  result[5] = matrix[5] * scalar;
+  result[6] = matrix[6] * scalar;
+  result[7] = matrix[7] * scalar;
+  result[8] = matrix[8] * scalar;
+  return result;
+};
+Matrix3.multiplyByScale = function(matrix, scale, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.object("scale", scale);
+  Check_default.typeOf.object("result", result);
+  result[0] = matrix[0] * scale.x;
+  result[1] = matrix[1] * scale.x;
+  result[2] = matrix[2] * scale.x;
+  result[3] = matrix[3] * scale.y;
+  result[4] = matrix[4] * scale.y;
+  result[5] = matrix[5] * scale.y;
+  result[6] = matrix[6] * scale.z;
+  result[7] = matrix[7] * scale.z;
+  result[8] = matrix[8] * scale.z;
+  return result;
+};
+Matrix3.multiplyByUniformScale = function(matrix, scale, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.number("scale", scale);
+  Check_default.typeOf.object("result", result);
+  result[0] = matrix[0] * scale;
+  result[1] = matrix[1] * scale;
+  result[2] = matrix[2] * scale;
+  result[3] = matrix[3] * scale;
+  result[4] = matrix[4] * scale;
+  result[5] = matrix[5] * scale;
+  result[6] = matrix[6] * scale;
+  result[7] = matrix[7] * scale;
+  result[8] = matrix[8] * scale;
+  return result;
+};
+Matrix3.negate = function(matrix, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.object("result", result);
+  result[0] = -matrix[0];
+  result[1] = -matrix[1];
+  result[2] = -matrix[2];
+  result[3] = -matrix[3];
+  result[4] = -matrix[4];
+  result[5] = -matrix[5];
+  result[6] = -matrix[6];
+  result[7] = -matrix[7];
+  result[8] = -matrix[8];
+  return result;
+};
+Matrix3.transpose = function(matrix, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.object("result", result);
+  const column0Row0 = matrix[0];
+  const column0Row1 = matrix[3];
+  const column0Row2 = matrix[6];
+  const column1Row0 = matrix[1];
+  const column1Row1 = matrix[4];
+  const column1Row2 = matrix[7];
+  const column2Row0 = matrix[2];
+  const column2Row1 = matrix[5];
+  const column2Row2 = matrix[8];
+  result[0] = column0Row0;
+  result[1] = column0Row1;
+  result[2] = column0Row2;
+  result[3] = column1Row0;
+  result[4] = column1Row1;
+  result[5] = column1Row2;
+  result[6] = column2Row0;
+  result[7] = column2Row1;
+  result[8] = column2Row2;
+  return result;
+};
+function computeFrobeniusNorm(matrix) {
+  let norm = 0;
+  for (let i = 0; i < 9; ++i) {
+    const temp = matrix[i];
+    norm += temp * temp;
+  }
+  return Math.sqrt(norm);
+}
+var rowVal = [1, 0, 0];
+var colVal = [2, 2, 1];
+function offDiagonalFrobeniusNorm(matrix) {
+  let norm = 0;
+  for (let i = 0; i < 3; ++i) {
+    const temp = matrix[Matrix3.getElementIndex(colVal[i], rowVal[i])];
+    norm += 2 * temp * temp;
+  }
+  return Math.sqrt(norm);
+}
+function shurDecomposition(matrix, result) {
+  const tolerance = Math_default.EPSILON15;
+  let maxDiagonal = 0;
+  let rotAxis = 1;
+  for (let i = 0; i < 3; ++i) {
+    const temp = Math.abs(
+      matrix[Matrix3.getElementIndex(colVal[i], rowVal[i])]
+    );
+    if (temp > maxDiagonal) {
+      rotAxis = i;
+      maxDiagonal = temp;
+    }
+  }
+  let c = 1;
+  let s = 0;
+  const p = rowVal[rotAxis];
+  const q = colVal[rotAxis];
+  if (Math.abs(matrix[Matrix3.getElementIndex(q, p)]) > tolerance) {
+    const qq = matrix[Matrix3.getElementIndex(q, q)];
+    const pp = matrix[Matrix3.getElementIndex(p, p)];
+    const qp = matrix[Matrix3.getElementIndex(q, p)];
+    const tau = (qq - pp) / 2 / qp;
+    let t;
+    if (tau < 0) {
+      t = -1 / (-tau + Math.sqrt(1 + tau * tau));
+    } else {
+      t = 1 / (tau + Math.sqrt(1 + tau * tau));
+    }
+    c = 1 / Math.sqrt(1 + t * t);
+    s = t * c;
+  }
+  result = Matrix3.clone(Matrix3.IDENTITY, result);
+  result[Matrix3.getElementIndex(p, p)] = result[Matrix3.getElementIndex(q, q)] = c;
+  result[Matrix3.getElementIndex(q, p)] = s;
+  result[Matrix3.getElementIndex(p, q)] = -s;
+  return result;
+}
+var jMatrix = new Matrix3();
+var jMatrixTranspose = new Matrix3();
+Matrix3.computeEigenDecomposition = function(matrix, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  const tolerance = Math_default.EPSILON20;
+  const maxSweeps = 10;
+  let count = 0;
+  let sweep = 0;
+  if (!defined_default(result)) {
+    result = {};
+  }
+  const unitaryMatrix = result.unitary = Matrix3.clone(
+    Matrix3.IDENTITY,
+    result.unitary
+  );
+  const diagMatrix = result.diagonal = Matrix3.clone(matrix, result.diagonal);
+  const epsilon = tolerance * computeFrobeniusNorm(diagMatrix);
+  while (sweep < maxSweeps && offDiagonalFrobeniusNorm(diagMatrix) > epsilon) {
+    shurDecomposition(diagMatrix, jMatrix);
+    Matrix3.transpose(jMatrix, jMatrixTranspose);
+    Matrix3.multiply(diagMatrix, jMatrix, diagMatrix);
+    Matrix3.multiply(jMatrixTranspose, diagMatrix, diagMatrix);
+    Matrix3.multiply(unitaryMatrix, jMatrix, unitaryMatrix);
+    if (++count > 2) {
+      ++sweep;
+      count = 0;
+    }
+  }
+  return result;
+};
+Matrix3.abs = function(matrix, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.object("result", result);
+  result[0] = Math.abs(matrix[0]);
+  result[1] = Math.abs(matrix[1]);
+  result[2] = Math.abs(matrix[2]);
+  result[3] = Math.abs(matrix[3]);
+  result[4] = Math.abs(matrix[4]);
+  result[5] = Math.abs(matrix[5]);
+  result[6] = Math.abs(matrix[6]);
+  result[7] = Math.abs(matrix[7]);
+  result[8] = Math.abs(matrix[8]);
+  return result;
+};
+Matrix3.determinant = function(matrix) {
+  Check_default.typeOf.object("matrix", matrix);
+  const m11 = matrix[0];
+  const m21 = matrix[3];
+  const m31 = matrix[6];
+  const m12 = matrix[1];
+  const m22 = matrix[4];
+  const m32 = matrix[7];
+  const m13 = matrix[2];
+  const m23 = matrix[5];
+  const m33 = matrix[8];
+  return m11 * (m22 * m33 - m23 * m32) + m12 * (m23 * m31 - m21 * m33) + m13 * (m21 * m32 - m22 * m31);
+};
+Matrix3.inverse = function(matrix, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.object("result", result);
+  const m11 = matrix[0];
+  const m21 = matrix[1];
+  const m31 = matrix[2];
+  const m12 = matrix[3];
+  const m22 = matrix[4];
+  const m32 = matrix[5];
+  const m13 = matrix[6];
+  const m23 = matrix[7];
+  const m33 = matrix[8];
+  const determinant = Matrix3.determinant(matrix);
+  if (Math.abs(determinant) <= Math_default.EPSILON15) {
+    throw new DeveloperError_default("matrix is not invertible");
+  }
+  result[0] = m22 * m33 - m23 * m32;
+  result[1] = m23 * m31 - m21 * m33;
+  result[2] = m21 * m32 - m22 * m31;
+  result[3] = m13 * m32 - m12 * m33;
+  result[4] = m11 * m33 - m13 * m31;
+  result[5] = m12 * m31 - m11 * m32;
+  result[6] = m12 * m23 - m13 * m22;
+  result[7] = m13 * m21 - m11 * m23;
+  result[8] = m11 * m22 - m12 * m21;
+  const scale = 1 / determinant;
+  return Matrix3.multiplyByScalar(result, scale, result);
+};
+var scratchTransposeMatrix = new Matrix3();
+Matrix3.inverseTranspose = function(matrix, result) {
+  Check_default.typeOf.object("matrix", matrix);
+  Check_default.typeOf.object("result", result);
+  return Matrix3.inverse(
+    Matrix3.transpose(matrix, scratchTransposeMatrix),
+    result
+  );
+};
+Matrix3.equals = function(left, right) {
+  return left === right || defined_default(left) && defined_default(right) && left[0] === right[0] && left[1] === right[1] && left[2] === right[2] && left[3] === right[3] && left[4] === right[4] && left[5] === right[5] && left[6] === right[6] && left[7] === right[7] && left[8] === right[8];
+};
+Matrix3.equalsEpsilon = function(left, right, epsilon) {
+  epsilon = defaultValue_default(epsilon, 0);
+  return left === right || defined_default(left) && defined_default(right) && Math.abs(left[0] - right[0]) <= epsilon && Math.abs(left[1] - right[1]) <= epsilon && Math.abs(left[2] - right[2]) <= epsilon && Math.abs(left[3] - right[3]) <= epsilon && Math.abs(left[4] - right[4]) <= epsilon && Math.abs(left[5] - right[5]) <= epsilon && Math.abs(left[6] - right[6]) <= epsilon && Math.abs(left[7] - right[7]) <= epsilon && Math.abs(left[8] - right[8]) <= epsilon;
+};
+Matrix3.IDENTITY = Object.freeze(
+  new Matrix3(1, 0, 0, 0, 1, 0, 0, 0, 1)
+);
+Matrix3.ZERO = Object.freeze(
+  new Matrix3(0, 0, 0, 0, 0, 0, 0, 0, 0)
+);
+Matrix3.COLUMN0ROW0 = 0;
+Matrix3.COLUMN0ROW1 = 1;
+Matrix3.COLUMN0ROW2 = 2;
+Matrix3.COLUMN1ROW0 = 3;
+Matrix3.COLUMN1ROW1 = 4;
+Matrix3.COLUMN1ROW2 = 5;
+Matrix3.COLUMN2ROW0 = 6;
+Matrix3.COLUMN2ROW1 = 7;
+Matrix3.COLUMN2ROW2 = 8;
+Object.defineProperties(Matrix3.prototype, {
+  /**
+   * Gets the number of items in the collection.
+   * @memberof Matrix3.prototype
+   *
+   * @type {number}
+   */
+  length: {
+    get: function() {
+      return Matrix3.packedLength;
+    }
+  }
+});
+Matrix3.prototype.clone = function(result) {
+  return Matrix3.clone(this, result);
+};
+Matrix3.prototype.equals = function(right) {
+  return Matrix3.equals(this, right);
+};
+Matrix3.equalsArray = function(matrix, array, offset) {
+  return matrix[0] === array[offset] && matrix[1] === array[offset + 1] && matrix[2] === array[offset + 2] && matrix[3] === array[offset + 3] && matrix[4] === array[offset + 4] && matrix[5] === array[offset + 5] && matrix[6] === array[offset + 6] && matrix[7] === array[offset + 7] && matrix[8] === array[offset + 8];
+};
+Matrix3.prototype.equalsEpsilon = function(right, epsilon) {
+  return Matrix3.equalsEpsilon(this, right, epsilon);
+};
+Matrix3.prototype.toString = function() {
+  return `(${this[0]}, ${this[3]}, ${this[6]})
+(${this[1]}, ${this[4]}, ${this[7]})
+(${this[2]}, ${this[5]}, ${this[8]})`;
+};
+var Matrix3_default = Matrix3;
+
+// packages/engine/Source/Core/Fullscreen.js
+var _supportsFullscreen;
+var _names = {
+  requestFullscreen: void 0,
+  exitFullscreen: void 0,
+  fullscreenEnabled: void 0,
+  fullscreenElement: void 0,
+  fullscreenchange: void 0,
+  fullscreenerror: void 0
+};
+var Fullscreen = {};
+Object.defineProperties(Fullscreen, {
+  /**
+   * The element that is currently fullscreen, if any.  To simply check if the
+   * browser is in fullscreen mode or not, use {@link Fullscreen#fullscreen}.
+   * @memberof Fullscreen
+   * @type {object}
+   * @readonly
+   */
+  element: {
+    get: function() {
+      if (!Fullscreen.supportsFullscreen()) {
+        return void 0;
+      }
+      return document[_names.fullscreenElement];
+    }
+  },
+  /**
+   * The name of the event on the document that is fired when fullscreen is
+   * entered or exited.  This event name is intended for use with addEventListener.
+   * In your event handler, to determine if the browser is in fullscreen mode or not,
+   * use {@link Fullscreen#fullscreen}.
+   * @memberof Fullscreen
+   * @type {string}
+   * @readonly
+   */
+  changeEventName: {
+    get: function() {
+      if (!Fullscreen.supportsFullscreen()) {
+        return void 0;
+      }
+      return _names.fullscreenchange;
+    }
+  },
+  /**
+   * The name of the event that is fired when a fullscreen error
+   * occurs.  This event name is intended for use with addEventListener.
+   * @memberof Fullscreen
+   * @type {string}
+   * @readonly
+   */
+  errorEventName: {
+    get: function() {
+      if (!Fullscreen.supportsFullscreen()) {
+        return void 0;
+      }
+      return _names.fullscreenerror;
+    }
+  },
+  /**
+   * Determine whether the browser will allow an element to be made fullscreen, or not.
+   * For example, by default, iframes cannot go fullscreen unless the containing page
+   * adds an "allowfullscreen" attribute (or prefixed equivalent).
+   * @memberof Fullscreen
+   * @type {boolean}
+   * @readonly
+   */
+  enabled: {
+    get: function() {
+      if (!Fullscreen.supportsFullscreen()) {
+        return void 0;
+      }
+      return document[_names.fullscreenEnabled];
+    }
+  },
+  /**
+   * Determines if the browser is currently in fullscreen mode.
+   * @memberof Fullscreen
+   * @type {boolean}
+   * @readonly
+   */
+  fullscreen: {
+    get: function() {
+      if (!Fullscreen.supportsFullscreen()) {
+        return void 0;
+      }
+      return Fullscreen.element !== null;
+    }
+  }
+});
+Fullscreen.supportsFullscreen = function() {
+  if (defined_default(_supportsFullscreen)) {
+    return _supportsFullscreen;
+  }
+  _supportsFullscreen = false;
+  const body = document.body;
+  if (typeof body.requestFullscreen === "function") {
+    _names.requestFullscreen = "requestFullscreen";
+    _names.exitFullscreen = "exitFullscreen";
+    _names.fullscreenEnabled = "fullscreenEnabled";
+    _names.fullscreenElement = "fullscreenElement";
+    _names.fullscreenchange = "fullscreenchange";
+    _names.fullscreenerror = "fullscreenerror";
+    _supportsFullscreen = true;
+    return _supportsFullscreen;
+  }
+  const prefixes = ["webkit", "moz", "o", "ms", "khtml"];
+  let name;
+  for (let i = 0, len = prefixes.length; i < len; ++i) {
+    const prefix = prefixes[i];
+    name = `${prefix}RequestFullscreen`;
+    if (typeof body[name] === "function") {
+      _names.requestFullscreen = name;
+      _supportsFullscreen = true;
+    } else {
+      name = `${prefix}RequestFullScreen`;
+      if (typeof body[name] === "function") {
+        _names.requestFullscreen = name;
+        _supportsFullscreen = true;
+      }
+    }
+    name = `${prefix}ExitFullscreen`;
+    if (typeof document[name] === "function") {
+      _names.exitFullscreen = name;
+    } else {
+      name = `${prefix}CancelFullScreen`;
+      if (typeof document[name] === "function") {
+        _names.exitFullscreen = name;
+      }
+    }
+    name = `${prefix}FullscreenEnabled`;
+    if (document[name] !== void 0) {
+      _names.fullscreenEnabled = name;
+    } else {
+      name = `${prefix}FullScreenEnabled`;
+      if (document[name] !== void 0) {
+        _names.fullscreenEnabled = name;
+      }
+    }
+    name = `${prefix}FullscreenElement`;
+    if (document[name] !== void 0) {
+      _names.fullscreenElement = name;
+    } else {
+      name = `${prefix}FullScreenElement`;
+      if (document[name] !== void 0) {
+        _names.fullscreenElement = name;
+      }
+    }
+    name = `${prefix}fullscreenchange`;
+    if (document[`on${name}`] !== void 0) {
+      if (prefix === "ms") {
+        name = "MSFullscreenChange";
+      }
+      _names.fullscreenchange = name;
+    }
+    name = `${prefix}fullscreenerror`;
+    if (document[`on${name}`] !== void 0) {
+      if (prefix === "ms") {
+        name = "MSFullscreenError";
+      }
+      _names.fullscreenerror = name;
+    }
+  }
+  return _supportsFullscreen;
+};
+Fullscreen.requestFullscreen = function(element, vrDevice) {
+  if (!Fullscreen.supportsFullscreen()) {
+    return;
+  }
+  element[_names.requestFullscreen]({ vrDisplay: vrDevice });
+};
+Fullscreen.exitFullscreen = function() {
+  if (!Fullscreen.supportsFullscreen()) {
+    return;
+  }
+  document[_names.exitFullscreen]();
+};
+Fullscreen._names = _names;
+var Fullscreen_default = Fullscreen;
+
+// packages/engine/Source/Core/FeatureDetection.js
+var theNavigator;
+if (typeof navigator !== "undefined") {
+  theNavigator = navigator;
+} else {
+  theNavigator = {};
+}
+function extractVersion(versionString) {
+  const parts = versionString.split(".");
+  for (let i = 0, len = parts.length; i < len; ++i) {
+    parts[i] = parseInt(parts[i], 10);
+  }
+  return parts;
+}
+var isChromeResult;
+var chromeVersionResult;
+function isChrome() {
+  if (!defined_default(isChromeResult)) {
+    isChromeResult = false;
+    if (!isEdge()) {
+      const fields = / Chrome\/([\.0-9]+)/.exec(theNavigator.userAgent);
+      if (fields !== null) {
+        isChromeResult = true;
+        chromeVersionResult = extractVersion(fields[1]);
+      }
+    }
+  }
+  return isChromeResult;
+}
+function chromeVersion() {
+  return isChrome() && chromeVersionResult;
+}
+var isSafariResult;
+var safariVersionResult;
+function isSafari() {
+  if (!defined_default(isSafariResult)) {
+    isSafariResult = false;
+    if (!isChrome() && !isEdge() && / Safari\/[\.0-9]+/.test(theNavigator.userAgent)) {
+      const fields = / Version\/([\.0-9]+)/.exec(theNavigator.userAgent);
+      if (fields !== null) {
+        isSafariResult = true;
+        safariVersionResult = extractVersion(fields[1]);
+      }
+    }
+  }
+  return isSafariResult;
+}
+function safariVersion() {
+  return isSafari() && safariVersionResult;
+}
+var isWebkitResult;
+var webkitVersionResult;
+function isWebkit() {
+  if (!defined_default(isWebkitResult)) {
+    isWebkitResult = false;
+    const fields = / AppleWebKit\/([\.0-9]+)(\+?)/.exec(theNavigator.userAgent);
+    if (fields !== null) {
+      isWebkitResult = true;
+      webkitVersionResult = extractVersion(fields[1]);
+      webkitVersionResult.isNightly = !!fields[2];
+    }
+  }
+  return isWebkitResult;
+}
+function webkitVersion() {
+  return isWebkit() && webkitVersionResult;
+}
+var isInternetExplorerResult;
+var internetExplorerVersionResult;
+function isInternetExplorer() {
+  if (!defined_default(isInternetExplorerResult)) {
+    isInternetExplorerResult = false;
+    let fields;
+    if (theNavigator.appName === "Microsoft Internet Explorer") {
+      fields = /MSIE ([0-9]{1,}[\.0-9]{0,})/.exec(theNavigator.userAgent);
+      if (fields !== null) {
+        isInternetExplorerResult = true;
+        internetExplorerVersionResult = extractVersion(fields[1]);
+      }
+    } else if (theNavigator.appName === "Netscape") {
+      fields = /Trident\/.*rv:([0-9]{1,}[\.0-9]{0,})/.exec(
+        theNavigator.userAgent
+      );
+      if (fields !== null) {
+        isInternetExplorerResult = true;
+        internetExplorerVersionResult = extractVersion(fields[1]);
+      }
+    }
+  }
+  return isInternetExplorerResult;
+}
+function internetExplorerVersion() {
+  return isInternetExplorer() && internetExplorerVersionResult;
+}
+var isEdgeResult;
+var edgeVersionResult;
+function isEdge() {
+  if (!defined_default(isEdgeResult)) {
+    isEdgeResult = false;
+    const fields = / Edg\/([\.0-9]+)/.exec(theNavigator.userAgent);
+    if (fields !== null) {
+      isEdgeResult = true;
+      edgeVersionResult = extractVersion(fields[1]);
+    }
+  }
+  return isEdgeResult;
+}
+function edgeVersion() {
+  return isEdge() && edgeVersionResult;
+}
+var isFirefoxResult;
+var firefoxVersionResult;
+function isFirefox() {
+  if (!defined_default(isFirefoxResult)) {
+    isFirefoxResult = false;
+    const fields = /Firefox\/([\.0-9]+)/.exec(theNavigator.userAgent);
+    if (fields !== null) {
+      isFirefoxResult = true;
+      firefoxVersionResult = extractVersion(fields[1]);
+    }
+  }
+  return isFirefoxResult;
+}
+var isWindowsResult;
+function isWindows() {
+  if (!defined_default(isWindowsResult)) {
+    isWindowsResult = /Windows/i.test(theNavigator.appVersion);
+  }
+  return isWindowsResult;
+}
+var isIPadOrIOSResult;
+function isIPadOrIOS() {
+  if (!defined_default(isIPadOrIOSResult)) {
+    isIPadOrIOSResult = navigator.platform === "iPhone" || navigator.platform === "iPod" || navigator.platform === "iPad";
+  }
+  return isIPadOrIOSResult;
+}
+function firefoxVersion() {
+  return isFirefox() && firefoxVersionResult;
+}
+var hasPointerEvents;
+function supportsPointerEvents() {
+  if (!defined_default(hasPointerEvents)) {
+    hasPointerEvents = typeof PointerEvent !== "undefined" && (!defined_default(theNavigator.pointerEnabled) || theNavigator.pointerEnabled);
+  }
+  return hasPointerEvents;
+}
+var imageRenderingValueResult;
+var supportsImageRenderingPixelatedResult;
+function supportsImageRenderingPixelated() {
+  if (!defined_default(supportsImageRenderingPixelatedResult)) {
+    const canvas = document.createElement("canvas");
+    canvas.setAttribute(
+      "style",
+      "image-rendering: -moz-crisp-edges;image-rendering: pixelated;"
+    );
+    const tmp = canvas.style.imageRendering;
+    supportsImageRenderingPixelatedResult = defined_default(tmp) && tmp !== "";
+    if (supportsImageRenderingPixelatedResult) {
+      imageRenderingValueResult = tmp;
+    }
+  }
+  return supportsImageRenderingPixelatedResult;
+}
+function imageRenderingValue() {
+  return supportsImageRenderingPixelated() ? imageRenderingValueResult : void 0;
+}
+function supportsWebP() {
+  if (!supportsWebP.initialized) {
+    throw new DeveloperError_default(
+      "You must call FeatureDetection.supportsWebP.initialize and wait for the promise to resolve before calling FeatureDetection.supportsWebP"
+    );
+  }
+  return supportsWebP._result;
+}
+supportsWebP._promise = void 0;
+supportsWebP._result = void 0;
+supportsWebP.initialize = function() {
+  if (defined_default(supportsWebP._promise)) {
+    return supportsWebP._promise;
+  }
+  supportsWebP._promise = new Promise((resolve) => {
+    const image = new Image();
+    image.onload = function() {
+      supportsWebP._result = image.width > 0 && image.height > 0;
+      resolve(supportsWebP._result);
+    };
+    image.onerror = function() {
+      supportsWebP._result = false;
+      resolve(supportsWebP._result);
+    };
+    image.src = "data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA";
+  });
+  return supportsWebP._promise;
+};
+Object.defineProperties(supportsWebP, {
+  initialized: {
+    get: function() {
+      return defined_default(supportsWebP._result);
+    }
+  }
+});
+var typedArrayTypes = [];
+if (typeof ArrayBuffer !== "undefined") {
+  typedArrayTypes.push(
+    Int8Array,
+    Uint8Array,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array
+  );
+  if (typeof Uint8ClampedArray !== "undefined") {
+    typedArrayTypes.push(Uint8ClampedArray);
+  }
+  if (typeof Uint8ClampedArray !== "undefined") {
+    typedArrayTypes.push(Uint8ClampedArray);
+  }
+  if (typeof BigInt64Array !== "undefined") {
+    typedArrayTypes.push(BigInt64Array);
+  }
+  if (typeof BigUint64Array !== "undefined") {
+    typedArrayTypes.push(BigUint64Array);
+  }
+}
+var FeatureDetection = {
+  isChrome,
+  chromeVersion,
+  isSafari,
+  safariVersion,
+  isWebkit,
+  webkitVersion,
+  isInternetExplorer,
+  internetExplorerVersion,
+  isEdge,
+  edgeVersion,
+  isFirefox,
+  firefoxVersion,
+  isWindows,
+  isIPadOrIOS,
+  hardwareConcurrency: defaultValue_default(theNavigator.hardwareConcurrency, 3),
+  supportsPointerEvents,
+  supportsImageRenderingPixelated,
+  supportsWebP,
+  imageRenderingValue,
+  typedArrayTypes
+};
+FeatureDetection.supportsBasis = function(scene) {
+  return FeatureDetection.supportsWebAssembly() && scene.context.supportsBasis;
+};
+FeatureDetection.supportsFullscreen = function() {
+  return Fullscreen_default.supportsFullscreen();
+};
+FeatureDetection.supportsTypedArrays = function() {
+  return typeof ArrayBuffer !== "undefined";
+};
+FeatureDetection.supportsBigInt64Array = function() {
+  return typeof BigInt64Array !== "undefined";
+};
+FeatureDetection.supportsBigUint64Array = function() {
+  return typeof BigUint64Array !== "undefined";
+};
+FeatureDetection.supportsBigInt = function() {
+  return typeof BigInt !== "undefined";
+};
+FeatureDetection.supportsWebWorkers = function() {
+  return typeof Worker !== "undefined";
+};
+FeatureDetection.supportsWebAssembly = function() {
+  return typeof WebAssembly !== "undefined";
+};
+FeatureDetection.supportsWebgl2 = function(scene) {
+  Check_default.defined("scene", scene);
+  return scene.context.webgl2;
+};
+FeatureDetection.supportsEsmWebWorkers = function() {
+  return !isFirefox() || parseInt(firefoxVersionResult) >= 114;
+};
+var FeatureDetection_default = FeatureDetection;
+
+export {
+  Cartesian3_default,
+  Cartographic_default,
+  Cartesian2_default,
+  Ellipsoid_default,
+  Matrix3_default,
+  FeatureDetection_default
+};

public/assets/cesium/Workers/chunk-GBT7MJ6X.js

+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.121.2
+ *
+ * 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.
+ */
+
+
+// packages/engine/Source/Core/GeometryOffsetAttribute.js
+var GeometryOffsetAttribute = {
+  NONE: 0,
+  TOP: 1,
+  ALL: 2
+};
+var GeometryOffsetAttribute_default = Object.freeze(GeometryOffsetAttribute);
+
+export {
+  GeometryOffsetAttribute_default
+};