Merge branch 'upload' into 'master'

upload application

See merge request !2

public/assets/cesium/Workers/createCoplanarPolygonGeometry.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 {
+  BoundingRectangle_default
+} from "./chunk-44QAAS4P.js";
+import {
+  CoplanarPolygonGeometryLibrary_default
+} from "./chunk-TK5IIG2F.js";
+import "./chunk-2PTKXHJB.js";
+import {
+  PolygonGeometryLibrary_default
+} from "./chunk-IZJ42N4W.js";
+import "./chunk-XWOUPGUF.js";
+import {
+  GeometryInstance_default
+} from "./chunk-YSIJTJ7N.js";
+import {
+  GeometryPipeline_default
+} from "./chunk-7ZZ5LMZY.js";
+import "./chunk-LJ2JQHJT.js";
+import "./chunk-NGZJIN5Z.js";
+import {
+  VertexFormat_default
+} from "./chunk-JBSKHTNX.js";
+import "./chunk-YK3QIKY7.js";
+import "./chunk-NDDI2LWR.js";
+import {
+  PolygonPipeline_default
+} from "./chunk-TI3TRKIC.js";
+import {
+  arrayRemoveDuplicates_default
+} from "./chunk-57H6I3SV.js";
+import "./chunk-JSQJDZI4.js";
+import "./chunk-QQOZO7KO.js";
+import "./chunk-EDLRS3AW.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 {
+  Quaternion_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian2_default,
+  Cartesian3_default,
+  Ellipsoid_default,
+  Matrix3_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.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/CoplanarPolygonGeometry.js
+var scratchPosition = new Cartesian3_default();
+var scratchBR = new BoundingRectangle_default();
+var stScratch = new Cartesian2_default();
+var textureCoordinatesOrigin = new Cartesian2_default();
+var scratchNormal = new Cartesian3_default();
+var scratchTangent = new Cartesian3_default();
+var scratchBitangent = new Cartesian3_default();
+var centerScratch = new Cartesian3_default();
+var axis1Scratch = new Cartesian3_default();
+var axis2Scratch = new Cartesian3_default();
+var quaternionScratch = new Quaternion_default();
+var textureMatrixScratch = new Matrix3_default();
+var tangentRotationScratch = new Matrix3_default();
+var surfaceNormalScratch = new Cartesian3_default();
+function createGeometryFromPolygon(polygon, vertexFormat, boundingRectangle, stRotation, hardcodedTextureCoordinates, projectPointTo2D, normal, tangent, bitangent) {
+  const positions = polygon.positions;
+  let indices = PolygonPipeline_default.triangulate(polygon.positions2D, polygon.holes);
+  if (indices.length < 3) {
+    indices = [0, 1, 2];
+  }
+  const newIndices = IndexDatatype_default.createTypedArray(
+    positions.length,
+    indices.length
+  );
+  newIndices.set(indices);
+  let textureMatrix = textureMatrixScratch;
+  if (stRotation !== 0) {
+    let rotation = Quaternion_default.fromAxisAngle(
+      normal,
+      stRotation,
+      quaternionScratch
+    );
+    textureMatrix = Matrix3_default.fromQuaternion(rotation, textureMatrix);
+    if (vertexFormat.tangent || vertexFormat.bitangent) {
+      rotation = Quaternion_default.fromAxisAngle(
+        normal,
+        -stRotation,
+        quaternionScratch
+      );
+      const tangentRotation = Matrix3_default.fromQuaternion(
+        rotation,
+        tangentRotationScratch
+      );
+      tangent = Cartesian3_default.normalize(
+        Matrix3_default.multiplyByVector(tangentRotation, tangent, tangent),
+        tangent
+      );
+      if (vertexFormat.bitangent) {
+        bitangent = Cartesian3_default.normalize(
+          Cartesian3_default.cross(normal, tangent, bitangent),
+          bitangent
+        );
+      }
+    }
+  } else {
+    textureMatrix = Matrix3_default.clone(Matrix3_default.IDENTITY, textureMatrix);
+  }
+  const stOrigin = textureCoordinatesOrigin;
+  if (vertexFormat.st) {
+    stOrigin.x = boundingRectangle.x;
+    stOrigin.y = boundingRectangle.y;
+  }
+  const length = positions.length;
+  const size = length * 3;
+  const flatPositions = new Float64Array(size);
+  const normals = vertexFormat.normal ? new Float32Array(size) : void 0;
+  const tangents = vertexFormat.tangent ? new Float32Array(size) : void 0;
+  const bitangents = vertexFormat.bitangent ? new Float32Array(size) : void 0;
+  const textureCoordinates = vertexFormat.st ? new Float32Array(length * 2) : void 0;
+  let positionIndex = 0;
+  let normalIndex = 0;
+  let bitangentIndex = 0;
+  let tangentIndex = 0;
+  let stIndex = 0;
+  for (let i = 0; i < length; i++) {
+    const position = positions[i];
+    flatPositions[positionIndex++] = position.x;
+    flatPositions[positionIndex++] = position.y;
+    flatPositions[positionIndex++] = position.z;
+    if (vertexFormat.st) {
+      if (defined_default(hardcodedTextureCoordinates) && hardcodedTextureCoordinates.positions.length === length) {
+        textureCoordinates[stIndex++] = hardcodedTextureCoordinates.positions[i].x;
+        textureCoordinates[stIndex++] = hardcodedTextureCoordinates.positions[i].y;
+      } else {
+        const p = Matrix3_default.multiplyByVector(
+          textureMatrix,
+          position,
+          scratchPosition
+        );
+        const st = projectPointTo2D(p, stScratch);
+        Cartesian2_default.subtract(st, stOrigin, st);
+        const stx = Math_default.clamp(st.x / boundingRectangle.width, 0, 1);
+        const sty = Math_default.clamp(st.y / boundingRectangle.height, 0, 1);
+        textureCoordinates[stIndex++] = stx;
+        textureCoordinates[stIndex++] = sty;
+      }
+    }
+    if (vertexFormat.normal) {
+      normals[normalIndex++] = normal.x;
+      normals[normalIndex++] = normal.y;
+      normals[normalIndex++] = normal.z;
+    }
+    if (vertexFormat.tangent) {
+      tangents[tangentIndex++] = tangent.x;
+      tangents[tangentIndex++] = tangent.y;
+      tangents[tangentIndex++] = tangent.z;
+    }
+    if (vertexFormat.bitangent) {
+      bitangents[bitangentIndex++] = bitangent.x;
+      bitangents[bitangentIndex++] = bitangent.y;
+      bitangents[bitangentIndex++] = bitangent.z;
+    }
+  }
+  const attributes = new GeometryAttributes_default();
+  if (vertexFormat.position) {
+    attributes.position = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.DOUBLE,
+      componentsPerAttribute: 3,
+      values: flatPositions
+    });
+  }
+  if (vertexFormat.normal) {
+    attributes.normal = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: normals
+    });
+  }
+  if (vertexFormat.tangent) {
+    attributes.tangent = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: tangents
+    });
+  }
+  if (vertexFormat.bitangent) {
+    attributes.bitangent = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: bitangents
+    });
+  }
+  if (vertexFormat.st) {
+    attributes.st = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 2,
+      values: textureCoordinates
+    });
+  }
+  return new Geometry_default({
+    attributes,
+    indices: newIndices,
+    primitiveType: PrimitiveType_default.TRIANGLES
+  });
+}
+function CoplanarPolygonGeometry(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const polygonHierarchy = options.polygonHierarchy;
+  const textureCoordinates = options.textureCoordinates;
+  Check_default.defined("options.polygonHierarchy", polygonHierarchy);
+  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
+  this._vertexFormat = VertexFormat_default.clone(vertexFormat);
+  this._polygonHierarchy = polygonHierarchy;
+  this._stRotation = defaultValue_default(options.stRotation, 0);
+  this._ellipsoid = Ellipsoid_default.clone(
+    defaultValue_default(options.ellipsoid, Ellipsoid_default.default)
+  );
+  this._workerName = "createCoplanarPolygonGeometry";
+  this._textureCoordinates = textureCoordinates;
+  this.packedLength = PolygonGeometryLibrary_default.computeHierarchyPackedLength(
+    polygonHierarchy,
+    Cartesian3_default
+  ) + VertexFormat_default.packedLength + Ellipsoid_default.packedLength + (defined_default(textureCoordinates) ? PolygonGeometryLibrary_default.computeHierarchyPackedLength(
+    textureCoordinates,
+    Cartesian2_default
+  ) : 1) + 2;
+}
+CoplanarPolygonGeometry.fromPositions = function(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  Check_default.defined("options.positions", options.positions);
+  const newOptions = {
+    polygonHierarchy: {
+      positions: options.positions
+    },
+    vertexFormat: options.vertexFormat,
+    stRotation: options.stRotation,
+    ellipsoid: options.ellipsoid,
+    textureCoordinates: options.textureCoordinates
+  };
+  return new CoplanarPolygonGeometry(newOptions);
+};
+CoplanarPolygonGeometry.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  startingIndex = PolygonGeometryLibrary_default.packPolygonHierarchy(
+    value._polygonHierarchy,
+    array,
+    startingIndex,
+    Cartesian3_default
+  );
+  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
+  startingIndex += Ellipsoid_default.packedLength;
+  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
+  startingIndex += VertexFormat_default.packedLength;
+  array[startingIndex++] = value._stRotation;
+  if (defined_default(value._textureCoordinates)) {
+    startingIndex = PolygonGeometryLibrary_default.packPolygonHierarchy(
+      value._textureCoordinates,
+      array,
+      startingIndex,
+      Cartesian2_default
+    );
+  } else {
+    array[startingIndex++] = -1;
+  }
+  array[startingIndex++] = value.packedLength;
+  return array;
+};
+var scratchEllipsoid = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
+var scratchVertexFormat = new VertexFormat_default();
+var scratchOptions = {
+  polygonHierarchy: {}
+};
+CoplanarPolygonGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const polygonHierarchy = PolygonGeometryLibrary_default.unpackPolygonHierarchy(
+    array,
+    startingIndex,
+    Cartesian3_default
+  );
+  startingIndex = polygonHierarchy.startingIndex;
+  delete polygonHierarchy.startingIndex;
+  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
+  startingIndex += Ellipsoid_default.packedLength;
+  const vertexFormat = VertexFormat_default.unpack(
+    array,
+    startingIndex,
+    scratchVertexFormat
+  );
+  startingIndex += VertexFormat_default.packedLength;
+  const stRotation = array[startingIndex++];
+  const textureCoordinates = array[startingIndex] === -1 ? void 0 : PolygonGeometryLibrary_default.unpackPolygonHierarchy(
+    array,
+    startingIndex,
+    Cartesian2_default
+  );
+  if (defined_default(textureCoordinates)) {
+    startingIndex = textureCoordinates.startingIndex;
+    delete textureCoordinates.startingIndex;
+  } else {
+    startingIndex++;
+  }
+  const packedLength = array[startingIndex++];
+  if (!defined_default(result)) {
+    result = new CoplanarPolygonGeometry(scratchOptions);
+  }
+  result._polygonHierarchy = polygonHierarchy;
+  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
+  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
+  result._stRotation = stRotation;
+  result._textureCoordinates = textureCoordinates;
+  result.packedLength = packedLength;
+  return result;
+};
+CoplanarPolygonGeometry.createGeometry = function(polygonGeometry) {
+  const vertexFormat = polygonGeometry._vertexFormat;
+  const polygonHierarchy = polygonGeometry._polygonHierarchy;
+  const stRotation = polygonGeometry._stRotation;
+  const textureCoordinates = polygonGeometry._textureCoordinates;
+  const hasTextureCoordinates = defined_default(textureCoordinates);
+  let outerPositions = polygonHierarchy.positions;
+  outerPositions = arrayRemoveDuplicates_default(
+    outerPositions,
+    Cartesian3_default.equalsEpsilon,
+    true
+  );
+  if (outerPositions.length < 3) {
+    return;
+  }
+  let normal = scratchNormal;
+  let tangent = scratchTangent;
+  let bitangent = scratchBitangent;
+  let axis1 = axis1Scratch;
+  const axis2 = axis2Scratch;
+  const validGeometry = CoplanarPolygonGeometryLibrary_default.computeProjectTo2DArguments(
+    outerPositions,
+    centerScratch,
+    axis1,
+    axis2
+  );
+  if (!validGeometry) {
+    return void 0;
+  }
+  normal = Cartesian3_default.cross(axis1, axis2, normal);
+  normal = Cartesian3_default.normalize(normal, normal);
+  if (!Cartesian3_default.equalsEpsilon(
+    centerScratch,
+    Cartesian3_default.ZERO,
+    Math_default.EPSILON6
+  )) {
+    const surfaceNormal = polygonGeometry._ellipsoid.geodeticSurfaceNormal(
+      centerScratch,
+      surfaceNormalScratch
+    );
+    if (Cartesian3_default.dot(normal, surfaceNormal) < 0) {
+      normal = Cartesian3_default.negate(normal, normal);
+      axis1 = Cartesian3_default.negate(axis1, axis1);
+    }
+  }
+  const projectPoints = CoplanarPolygonGeometryLibrary_default.createProjectPointsTo2DFunction(
+    centerScratch,
+    axis1,
+    axis2
+  );
+  const projectPoint = CoplanarPolygonGeometryLibrary_default.createProjectPointTo2DFunction(
+    centerScratch,
+    axis1,
+    axis2
+  );
+  if (vertexFormat.tangent) {
+    tangent = Cartesian3_default.clone(axis1, tangent);
+  }
+  if (vertexFormat.bitangent) {
+    bitangent = Cartesian3_default.clone(axis2, bitangent);
+  }
+  const results = PolygonGeometryLibrary_default.polygonsFromHierarchy(
+    polygonHierarchy,
+    hasTextureCoordinates,
+    projectPoints,
+    false
+  );
+  const hierarchy = results.hierarchy;
+  const polygons = results.polygons;
+  const dummyFunction = function(identity) {
+    return identity;
+  };
+  const textureCoordinatePolygons = hasTextureCoordinates ? PolygonGeometryLibrary_default.polygonsFromHierarchy(
+    textureCoordinates,
+    true,
+    dummyFunction,
+    false
+  ).polygons : void 0;
+  if (hierarchy.length === 0) {
+    return;
+  }
+  outerPositions = hierarchy[0].outerRing;
+  const boundingSphere = BoundingSphere_default.fromPoints(outerPositions);
+  const boundingRectangle = PolygonGeometryLibrary_default.computeBoundingRectangle(
+    normal,
+    projectPoint,
+    outerPositions,
+    stRotation,
+    scratchBR
+  );
+  const geometries = [];
+  for (let i = 0; i < polygons.length; i++) {
+    const geometryInstance = new GeometryInstance_default({
+      geometry: createGeometryFromPolygon(
+        polygons[i],
+        vertexFormat,
+        boundingRectangle,
+        stRotation,
+        hasTextureCoordinates ? textureCoordinatePolygons[i] : void 0,
+        projectPoint,
+        normal,
+        tangent,
+        bitangent
+      )
+    });
+    geometries.push(geometryInstance);
+  }
+  const geometry = GeometryPipeline_default.combineInstances(geometries)[0];
+  geometry.attributes.position.values = new Float64Array(
+    geometry.attributes.position.values
+  );
+  geometry.indices = IndexDatatype_default.createTypedArray(
+    geometry.attributes.position.values.length / 3,
+    geometry.indices
+  );
+  const attributes = geometry.attributes;
+  if (!vertexFormat.position) {
+    delete attributes.position;
+  }
+  return new Geometry_default({
+    attributes,
+    indices: geometry.indices,
+    primitiveType: geometry.primitiveType,
+    boundingSphere
+  });
+};
+var CoplanarPolygonGeometry_default = CoplanarPolygonGeometry;
+
+// packages/engine/Source/Workers/createCoplanarPolygonGeometry.js
+function createCoplanarPolygonGeometry(polygonGeometry, offset) {
+  if (defined_default(offset)) {
+    polygonGeometry = CoplanarPolygonGeometry_default.unpack(polygonGeometry, offset);
+  }
+  return CoplanarPolygonGeometry_default.createGeometry(polygonGeometry);
+}
+var createCoplanarPolygonGeometry_default = createCoplanarPolygonGeometry;
+export {
+  createCoplanarPolygonGeometry_default as default
+};

public/assets/cesium/Workers/createCoplanarPolygonOutlineGeometry.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 {
+  CoplanarPolygonGeometryLibrary_default
+} from "./chunk-TK5IIG2F.js";
+import "./chunk-2PTKXHJB.js";
+import {
+  PolygonGeometryLibrary_default
+} from "./chunk-IZJ42N4W.js";
+import "./chunk-XWOUPGUF.js";
+import {
+  GeometryInstance_default
+} from "./chunk-YSIJTJ7N.js";
+import {
+  GeometryPipeline_default
+} from "./chunk-7ZZ5LMZY.js";
+import "./chunk-LJ2JQHJT.js";
+import "./chunk-NGZJIN5Z.js";
+import "./chunk-YK3QIKY7.js";
+import "./chunk-NDDI2LWR.js";
+import "./chunk-TI3TRKIC.js";
+import {
+  arrayRemoveDuplicates_default
+} from "./chunk-57H6I3SV.js";
+import "./chunk-JSQJDZI4.js";
+import "./chunk-QQOZO7KO.js";
+import "./chunk-EDLRS3AW.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 "./chunk-6SQMLVGV.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian3_default,
+  Ellipsoid_default
+} from "./chunk-FFLMY4TE.js";
+import "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.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/CoplanarPolygonOutlineGeometry.js
+function createGeometryFromPositions(positions) {
+  const length = positions.length;
+  const flatPositions = new Float64Array(length * 3);
+  const indices = IndexDatatype_default.createTypedArray(length, length * 2);
+  let positionIndex = 0;
+  let index = 0;
+  for (let i = 0; i < length; i++) {
+    const position = positions[i];
+    flatPositions[positionIndex++] = position.x;
+    flatPositions[positionIndex++] = position.y;
+    flatPositions[positionIndex++] = position.z;
+    indices[index++] = i;
+    indices[index++] = (i + 1) % length;
+  }
+  const attributes = new GeometryAttributes_default({
+    position: new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.DOUBLE,
+      componentsPerAttribute: 3,
+      values: flatPositions
+    })
+  });
+  return new Geometry_default({
+    attributes,
+    indices,
+    primitiveType: PrimitiveType_default.LINES
+  });
+}
+function CoplanarPolygonOutlineGeometry(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const polygonHierarchy = options.polygonHierarchy;
+  Check_default.defined("options.polygonHierarchy", polygonHierarchy);
+  this._polygonHierarchy = polygonHierarchy;
+  this._workerName = "createCoplanarPolygonOutlineGeometry";
+  this.packedLength = PolygonGeometryLibrary_default.computeHierarchyPackedLength(
+    polygonHierarchy,
+    Cartesian3_default
+  ) + 1;
+}
+CoplanarPolygonOutlineGeometry.fromPositions = function(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  Check_default.defined("options.positions", options.positions);
+  const newOptions = {
+    polygonHierarchy: {
+      positions: options.positions
+    }
+  };
+  return new CoplanarPolygonOutlineGeometry(newOptions);
+};
+CoplanarPolygonOutlineGeometry.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  startingIndex = PolygonGeometryLibrary_default.packPolygonHierarchy(
+    value._polygonHierarchy,
+    array,
+    startingIndex,
+    Cartesian3_default
+  );
+  array[startingIndex] = value.packedLength;
+  return array;
+};
+var scratchOptions = {
+  polygonHierarchy: {}
+};
+CoplanarPolygonOutlineGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const polygonHierarchy = PolygonGeometryLibrary_default.unpackPolygonHierarchy(
+    array,
+    startingIndex,
+    Cartesian3_default
+  );
+  startingIndex = polygonHierarchy.startingIndex;
+  delete polygonHierarchy.startingIndex;
+  const packedLength = array[startingIndex];
+  if (!defined_default(result)) {
+    result = new CoplanarPolygonOutlineGeometry(scratchOptions);
+  }
+  result._polygonHierarchy = polygonHierarchy;
+  result.packedLength = packedLength;
+  return result;
+};
+CoplanarPolygonOutlineGeometry.createGeometry = function(polygonGeometry) {
+  const polygonHierarchy = polygonGeometry._polygonHierarchy;
+  let outerPositions = polygonHierarchy.positions;
+  outerPositions = arrayRemoveDuplicates_default(
+    outerPositions,
+    Cartesian3_default.equalsEpsilon,
+    true
+  );
+  if (outerPositions.length < 3) {
+    return;
+  }
+  const isValid = CoplanarPolygonGeometryLibrary_default.validOutline(outerPositions);
+  if (!isValid) {
+    return void 0;
+  }
+  const polygons = PolygonGeometryLibrary_default.polygonOutlinesFromHierarchy(
+    polygonHierarchy,
+    false
+  );
+  if (polygons.length === 0) {
+    return void 0;
+  }
+  const geometries = [];
+  for (let i = 0; i < polygons.length; i++) {
+    const geometryInstance = new GeometryInstance_default({
+      geometry: createGeometryFromPositions(polygons[i])
+    });
+    geometries.push(geometryInstance);
+  }
+  const geometry = GeometryPipeline_default.combineInstances(geometries)[0];
+  const boundingSphere = BoundingSphere_default.fromPoints(polygonHierarchy.positions);
+  return new Geometry_default({
+    attributes: geometry.attributes,
+    indices: geometry.indices,
+    primitiveType: geometry.primitiveType,
+    boundingSphere
+  });
+};
+var CoplanarPolygonOutlineGeometry_default = CoplanarPolygonOutlineGeometry;
+
+// packages/engine/Source/Workers/createCoplanarPolygonOutlineGeometry.js
+function createCoplanarPolygonOutlineGeometry(polygonGeometry, offset) {
+  if (defined_default(offset)) {
+    polygonGeometry = CoplanarPolygonOutlineGeometry_default.unpack(
+      polygonGeometry,
+      offset
+    );
+  }
+  polygonGeometry._ellipsoid = Ellipsoid_default.clone(polygonGeometry._ellipsoid);
+  return CoplanarPolygonOutlineGeometry_default.createGeometry(polygonGeometry);
+}
+var createCoplanarPolygonOutlineGeometry_default = createCoplanarPolygonOutlineGeometry;
+export {
+  createCoplanarPolygonOutlineGeometry_default as default
+};

public/assets/cesium/Workers/createCorridorGeometry.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 {
+  CorridorGeometryLibrary_default
+} from "./chunk-EJVGYGLF.js";
+import {
+  CornerType_default
+} from "./chunk-3IFRSGEY.js";
+import "./chunk-QN6TBED4.js";
+import "./chunk-C3EQ27WF.js";
+import {
+  GeometryOffsetAttribute_default
+} from "./chunk-GBT7MJ6X.js";
+import {
+  VertexFormat_default
+} from "./chunk-JBSKHTNX.js";
+import "./chunk-YK3QIKY7.js";
+import "./chunk-NDDI2LWR.js";
+import {
+  PolygonPipeline_default
+} from "./chunk-TI3TRKIC.js";
+import {
+  arrayRemoveDuplicates_default
+} from "./chunk-57H6I3SV.js";
+import "./chunk-JSQJDZI4.js";
+import "./chunk-QQOZO7KO.js";
+import "./chunk-EDLRS3AW.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 {
+  Rectangle_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian3_default,
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.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/CorridorGeometry.js
+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 scratch1 = new Cartesian3_default();
+var scratch2 = new Cartesian3_default();
+function scaleToSurface(positions, ellipsoid) {
+  for (let i = 0; i < positions.length; i++) {
+    positions[i] = ellipsoid.scaleToGeodeticSurface(positions[i], positions[i]);
+  }
+  return positions;
+}
+function addNormals(attr, normal, left, front, back, vertexFormat) {
+  const normals = attr.normals;
+  const tangents = attr.tangents;
+  const bitangents = attr.bitangents;
+  const forward = Cartesian3_default.normalize(
+    Cartesian3_default.cross(left, normal, scratch1),
+    scratch1
+  );
+  if (vertexFormat.normal) {
+    CorridorGeometryLibrary_default.addAttribute(normals, normal, front, back);
+  }
+  if (vertexFormat.tangent) {
+    CorridorGeometryLibrary_default.addAttribute(tangents, forward, front, back);
+  }
+  if (vertexFormat.bitangent) {
+    CorridorGeometryLibrary_default.addAttribute(bitangents, left, front, back);
+  }
+}
+function combine(computedPositions, vertexFormat, ellipsoid) {
+  const positions = computedPositions.positions;
+  const corners = computedPositions.corners;
+  const endPositions = computedPositions.endPositions;
+  const computedLefts = computedPositions.lefts;
+  const computedNormals = computedPositions.normals;
+  const attributes = new GeometryAttributes_default();
+  let corner;
+  let leftCount = 0;
+  let rightCount = 0;
+  let i;
+  let indicesLength = 0;
+  let length;
+  for (i = 0; i < positions.length; i += 2) {
+    length = positions[i].length - 3;
+    leftCount += length;
+    indicesLength += length * 2;
+    rightCount += positions[i + 1].length - 3;
+  }
+  leftCount += 3;
+  rightCount += 3;
+  for (i = 0; i < corners.length; i++) {
+    corner = corners[i];
+    const leftSide = corners[i].leftPositions;
+    if (defined_default(leftSide)) {
+      length = leftSide.length;
+      leftCount += length;
+      indicesLength += length;
+    } else {
+      length = corners[i].rightPositions.length;
+      rightCount += length;
+      indicesLength += length;
+    }
+  }
+  const addEndPositions = defined_default(endPositions);
+  let endPositionLength;
+  if (addEndPositions) {
+    endPositionLength = endPositions[0].length - 3;
+    leftCount += endPositionLength;
+    rightCount += endPositionLength;
+    endPositionLength /= 3;
+    indicesLength += endPositionLength * 6;
+  }
+  const size = leftCount + rightCount;
+  const finalPositions = new Float64Array(size);
+  const normals = vertexFormat.normal ? new Float32Array(size) : void 0;
+  const tangents = vertexFormat.tangent ? new Float32Array(size) : void 0;
+  const bitangents = vertexFormat.bitangent ? new Float32Array(size) : void 0;
+  const attr = {
+    normals,
+    tangents,
+    bitangents
+  };
+  let front = 0;
+  let back = size - 1;
+  let UL, LL, UR, LR;
+  let normal = cartesian1;
+  let left = cartesian2;
+  let rightPos, leftPos;
+  const halfLength = endPositionLength / 2;
+  const indices = IndexDatatype_default.createTypedArray(size / 3, indicesLength);
+  let index = 0;
+  if (addEndPositions) {
+    leftPos = cartesian3;
+    rightPos = cartesian4;
+    const firstEndPositions = endPositions[0];
+    normal = Cartesian3_default.fromArray(computedNormals, 0, normal);
+    left = Cartesian3_default.fromArray(computedLefts, 0, left);
+    for (i = 0; i < halfLength; i++) {
+      leftPos = Cartesian3_default.fromArray(
+        firstEndPositions,
+        (halfLength - 1 - i) * 3,
+        leftPos
+      );
+      rightPos = Cartesian3_default.fromArray(
+        firstEndPositions,
+        (halfLength + i) * 3,
+        rightPos
+      );
+      CorridorGeometryLibrary_default.addAttribute(finalPositions, rightPos, front);
+      CorridorGeometryLibrary_default.addAttribute(
+        finalPositions,
+        leftPos,
+        void 0,
+        back
+      );
+      addNormals(attr, normal, left, front, back, vertexFormat);
+      LL = front / 3;
+      LR = LL + 1;
+      UL = (back - 2) / 3;
+      UR = UL - 1;
+      indices[index++] = UL;
+      indices[index++] = LL;
+      indices[index++] = UR;
+      indices[index++] = UR;
+      indices[index++] = LL;
+      indices[index++] = LR;
+      front += 3;
+      back -= 3;
+    }
+  }
+  let posIndex = 0;
+  let compIndex = 0;
+  let rightEdge = positions[posIndex++];
+  let leftEdge = positions[posIndex++];
+  finalPositions.set(rightEdge, front);
+  finalPositions.set(leftEdge, back - leftEdge.length + 1);
+  left = Cartesian3_default.fromArray(computedLefts, compIndex, left);
+  let rightNormal;
+  let leftNormal;
+  length = leftEdge.length - 3;
+  for (i = 0; i < length; i += 3) {
+    rightNormal = ellipsoid.geodeticSurfaceNormal(
+      Cartesian3_default.fromArray(rightEdge, i, scratch1),
+      scratch1
+    );
+    leftNormal = ellipsoid.geodeticSurfaceNormal(
+      Cartesian3_default.fromArray(leftEdge, length - i, scratch2),
+      scratch2
+    );
+    normal = Cartesian3_default.normalize(
+      Cartesian3_default.add(rightNormal, leftNormal, normal),
+      normal
+    );
+    addNormals(attr, normal, left, front, back, vertexFormat);
+    LL = front / 3;
+    LR = LL + 1;
+    UL = (back - 2) / 3;
+    UR = UL - 1;
+    indices[index++] = UL;
+    indices[index++] = LL;
+    indices[index++] = UR;
+    indices[index++] = UR;
+    indices[index++] = LL;
+    indices[index++] = LR;
+    front += 3;
+    back -= 3;
+  }
+  rightNormal = ellipsoid.geodeticSurfaceNormal(
+    Cartesian3_default.fromArray(rightEdge, length, scratch1),
+    scratch1
+  );
+  leftNormal = ellipsoid.geodeticSurfaceNormal(
+    Cartesian3_default.fromArray(leftEdge, length, scratch2),
+    scratch2
+  );
+  normal = Cartesian3_default.normalize(
+    Cartesian3_default.add(rightNormal, leftNormal, normal),
+    normal
+  );
+  compIndex += 3;
+  for (i = 0; i < corners.length; i++) {
+    let j;
+    corner = corners[i];
+    const l = corner.leftPositions;
+    const r = corner.rightPositions;
+    let pivot;
+    let start;
+    let outsidePoint = cartesian6;
+    let previousPoint = cartesian3;
+    let nextPoint = cartesian4;
+    normal = Cartesian3_default.fromArray(computedNormals, compIndex, normal);
+    if (defined_default(l)) {
+      addNormals(attr, normal, left, void 0, back, vertexFormat);
+      back -= 3;
+      pivot = LR;
+      start = UR;
+      for (j = 0; j < l.length / 3; j++) {
+        outsidePoint = Cartesian3_default.fromArray(l, j * 3, outsidePoint);
+        indices[index++] = pivot;
+        indices[index++] = start - j - 1;
+        indices[index++] = start - j;
+        CorridorGeometryLibrary_default.addAttribute(
+          finalPositions,
+          outsidePoint,
+          void 0,
+          back
+        );
+        previousPoint = Cartesian3_default.fromArray(
+          finalPositions,
+          (start - j - 1) * 3,
+          previousPoint
+        );
+        nextPoint = Cartesian3_default.fromArray(finalPositions, pivot * 3, nextPoint);
+        left = Cartesian3_default.normalize(
+          Cartesian3_default.subtract(previousPoint, nextPoint, left),
+          left
+        );
+        addNormals(attr, normal, left, void 0, back, vertexFormat);
+        back -= 3;
+      }
+      outsidePoint = Cartesian3_default.fromArray(
+        finalPositions,
+        pivot * 3,
+        outsidePoint
+      );
+      previousPoint = Cartesian3_default.subtract(
+        Cartesian3_default.fromArray(finalPositions, start * 3, previousPoint),
+        outsidePoint,
+        previousPoint
+      );
+      nextPoint = Cartesian3_default.subtract(
+        Cartesian3_default.fromArray(finalPositions, (start - j) * 3, nextPoint),
+        outsidePoint,
+        nextPoint
+      );
+      left = Cartesian3_default.normalize(
+        Cartesian3_default.add(previousPoint, nextPoint, left),
+        left
+      );
+      addNormals(attr, normal, left, front, void 0, vertexFormat);
+      front += 3;
+    } else {
+      addNormals(attr, normal, left, front, void 0, vertexFormat);
+      front += 3;
+      pivot = UR;
+      start = LR;
+      for (j = 0; j < r.length / 3; j++) {
+        outsidePoint = Cartesian3_default.fromArray(r, j * 3, outsidePoint);
+        indices[index++] = pivot;
+        indices[index++] = start + j;
+        indices[index++] = start + j + 1;
+        CorridorGeometryLibrary_default.addAttribute(
+          finalPositions,
+          outsidePoint,
+          front
+        );
+        previousPoint = Cartesian3_default.fromArray(
+          finalPositions,
+          pivot * 3,
+          previousPoint
+        );
+        nextPoint = Cartesian3_default.fromArray(
+          finalPositions,
+          (start + j) * 3,
+          nextPoint
+        );
+        left = Cartesian3_default.normalize(
+          Cartesian3_default.subtract(previousPoint, nextPoint, left),
+          left
+        );
+        addNormals(attr, normal, left, front, void 0, vertexFormat);
+        front += 3;
+      }
+      outsidePoint = Cartesian3_default.fromArray(
+        finalPositions,
+        pivot * 3,
+        outsidePoint
+      );
+      previousPoint = Cartesian3_default.subtract(
+        Cartesian3_default.fromArray(finalPositions, (start + j) * 3, previousPoint),
+        outsidePoint,
+        previousPoint
+      );
+      nextPoint = Cartesian3_default.subtract(
+        Cartesian3_default.fromArray(finalPositions, start * 3, nextPoint),
+        outsidePoint,
+        nextPoint
+      );
+      left = Cartesian3_default.normalize(
+        Cartesian3_default.negate(Cartesian3_default.add(nextPoint, previousPoint, left), left),
+        left
+      );
+      addNormals(attr, normal, left, void 0, back, vertexFormat);
+      back -= 3;
+    }
+    rightEdge = positions[posIndex++];
+    leftEdge = positions[posIndex++];
+    rightEdge.splice(0, 3);
+    leftEdge.splice(leftEdge.length - 3, 3);
+    finalPositions.set(rightEdge, front);
+    finalPositions.set(leftEdge, back - leftEdge.length + 1);
+    length = leftEdge.length - 3;
+    compIndex += 3;
+    left = Cartesian3_default.fromArray(computedLefts, compIndex, left);
+    for (j = 0; j < leftEdge.length; j += 3) {
+      rightNormal = ellipsoid.geodeticSurfaceNormal(
+        Cartesian3_default.fromArray(rightEdge, j, scratch1),
+        scratch1
+      );
+      leftNormal = ellipsoid.geodeticSurfaceNormal(
+        Cartesian3_default.fromArray(leftEdge, length - j, scratch2),
+        scratch2
+      );
+      normal = Cartesian3_default.normalize(
+        Cartesian3_default.add(rightNormal, leftNormal, normal),
+        normal
+      );
+      addNormals(attr, normal, left, front, back, vertexFormat);
+      LR = front / 3;
+      LL = LR - 1;
+      UR = (back - 2) / 3;
+      UL = UR + 1;
+      indices[index++] = UL;
+      indices[index++] = LL;
+      indices[index++] = UR;
+      indices[index++] = UR;
+      indices[index++] = LL;
+      indices[index++] = LR;
+      front += 3;
+      back -= 3;
+    }
+    front -= 3;
+    back += 3;
+  }
+  normal = Cartesian3_default.fromArray(
+    computedNormals,
+    computedNormals.length - 3,
+    normal
+  );
+  addNormals(attr, normal, left, front, back, vertexFormat);
+  if (addEndPositions) {
+    front += 3;
+    back -= 3;
+    leftPos = cartesian3;
+    rightPos = cartesian4;
+    const lastEndPositions = endPositions[1];
+    for (i = 0; i < halfLength; i++) {
+      leftPos = Cartesian3_default.fromArray(
+        lastEndPositions,
+        (endPositionLength - i - 1) * 3,
+        leftPos
+      );
+      rightPos = Cartesian3_default.fromArray(lastEndPositions, i * 3, rightPos);
+      CorridorGeometryLibrary_default.addAttribute(
+        finalPositions,
+        leftPos,
+        void 0,
+        back
+      );
+      CorridorGeometryLibrary_default.addAttribute(finalPositions, rightPos, front);
+      addNormals(attr, normal, left, front, back, vertexFormat);
+      LR = front / 3;
+      LL = LR - 1;
+      UR = (back - 2) / 3;
+      UL = UR + 1;
+      indices[index++] = UL;
+      indices[index++] = LL;
+      indices[index++] = UR;
+      indices[index++] = UR;
+      indices[index++] = LL;
+      indices[index++] = LR;
+      front += 3;
+      back -= 3;
+    }
+  }
+  attributes.position = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.DOUBLE,
+    componentsPerAttribute: 3,
+    values: finalPositions
+  });
+  if (vertexFormat.st) {
+    const st = new Float32Array(size / 3 * 2);
+    let rightSt;
+    let leftSt;
+    let stIndex = 0;
+    if (addEndPositions) {
+      leftCount /= 3;
+      rightCount /= 3;
+      const theta = Math.PI / (endPositionLength + 1);
+      leftSt = 1 / (leftCount - endPositionLength + 1);
+      rightSt = 1 / (rightCount - endPositionLength + 1);
+      let a;
+      const halfEndPos = endPositionLength / 2;
+      for (i = halfEndPos + 1; i < endPositionLength + 1; i++) {
+        a = Math_default.PI_OVER_TWO + theta * i;
+        st[stIndex++] = rightSt * (1 + Math.cos(a));
+        st[stIndex++] = 0.5 * (1 + Math.sin(a));
+      }
+      for (i = 1; i < rightCount - endPositionLength + 1; i++) {
+        st[stIndex++] = i * rightSt;
+        st[stIndex++] = 0;
+      }
+      for (i = endPositionLength; i > halfEndPos; i--) {
+        a = Math_default.PI_OVER_TWO - i * theta;
+        st[stIndex++] = 1 - rightSt * (1 + Math.cos(a));
+        st[stIndex++] = 0.5 * (1 + Math.sin(a));
+      }
+      for (i = halfEndPos; i > 0; i--) {
+        a = Math_default.PI_OVER_TWO - theta * i;
+        st[stIndex++] = 1 - leftSt * (1 + Math.cos(a));
+        st[stIndex++] = 0.5 * (1 + Math.sin(a));
+      }
+      for (i = leftCount - endPositionLength; i > 0; i--) {
+        st[stIndex++] = i * leftSt;
+        st[stIndex++] = 1;
+      }
+      for (i = 1; i < halfEndPos + 1; i++) {
+        a = Math_default.PI_OVER_TWO + theta * i;
+        st[stIndex++] = leftSt * (1 + Math.cos(a));
+        st[stIndex++] = 0.5 * (1 + Math.sin(a));
+      }
+    } else {
+      leftCount /= 3;
+      rightCount /= 3;
+      leftSt = 1 / (leftCount - 1);
+      rightSt = 1 / (rightCount - 1);
+      for (i = 0; i < rightCount; i++) {
+        st[stIndex++] = i * rightSt;
+        st[stIndex++] = 0;
+      }
+      for (i = leftCount; i > 0; i--) {
+        st[stIndex++] = (i - 1) * leftSt;
+        st[stIndex++] = 1;
+      }
+    }
+    attributes.st = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 2,
+      values: st
+    });
+  }
+  if (vertexFormat.normal) {
+    attributes.normal = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: attr.normals
+    });
+  }
+  if (vertexFormat.tangent) {
+    attributes.tangent = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: attr.tangents
+    });
+  }
+  if (vertexFormat.bitangent) {
+    attributes.bitangent = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: attr.bitangents
+    });
+  }
+  return {
+    attributes,
+    indices
+  };
+}
+function extrudedAttributes(attributes, vertexFormat) {
+  if (!vertexFormat.normal && !vertexFormat.tangent && !vertexFormat.bitangent && !vertexFormat.st) {
+    return attributes;
+  }
+  const positions = attributes.position.values;
+  let topNormals;
+  let topBitangents;
+  if (vertexFormat.normal || vertexFormat.bitangent) {
+    topNormals = attributes.normal.values;
+    topBitangents = attributes.bitangent.values;
+  }
+  const size = attributes.position.values.length / 18;
+  const threeSize = size * 3;
+  const twoSize = size * 2;
+  const sixSize = threeSize * 2;
+  let i;
+  if (vertexFormat.normal || vertexFormat.bitangent || vertexFormat.tangent) {
+    const normals = vertexFormat.normal ? new Float32Array(threeSize * 6) : void 0;
+    const tangents = vertexFormat.tangent ? new Float32Array(threeSize * 6) : void 0;
+    const bitangents = vertexFormat.bitangent ? new Float32Array(threeSize * 6) : void 0;
+    let topPosition = cartesian1;
+    let bottomPosition = cartesian2;
+    let previousPosition = cartesian3;
+    let normal = cartesian4;
+    let tangent = cartesian5;
+    let bitangent = cartesian6;
+    let attrIndex = sixSize;
+    for (i = 0; i < threeSize; i += 3) {
+      const attrIndexOffset = attrIndex + sixSize;
+      topPosition = Cartesian3_default.fromArray(positions, i, topPosition);
+      bottomPosition = Cartesian3_default.fromArray(
+        positions,
+        i + threeSize,
+        bottomPosition
+      );
+      previousPosition = Cartesian3_default.fromArray(
+        positions,
+        (i + 3) % threeSize,
+        previousPosition
+      );
+      bottomPosition = Cartesian3_default.subtract(
+        bottomPosition,
+        topPosition,
+        bottomPosition
+      );
+      previousPosition = Cartesian3_default.subtract(
+        previousPosition,
+        topPosition,
+        previousPosition
+      );
+      normal = Cartesian3_default.normalize(
+        Cartesian3_default.cross(bottomPosition, previousPosition, normal),
+        normal
+      );
+      if (vertexFormat.normal) {
+        CorridorGeometryLibrary_default.addAttribute(normals, normal, attrIndexOffset);
+        CorridorGeometryLibrary_default.addAttribute(
+          normals,
+          normal,
+          attrIndexOffset + 3
+        );
+        CorridorGeometryLibrary_default.addAttribute(normals, normal, attrIndex);
+        CorridorGeometryLibrary_default.addAttribute(normals, normal, attrIndex + 3);
+      }
+      if (vertexFormat.tangent || vertexFormat.bitangent) {
+        bitangent = Cartesian3_default.fromArray(topNormals, i, bitangent);
+        if (vertexFormat.bitangent) {
+          CorridorGeometryLibrary_default.addAttribute(
+            bitangents,
+            bitangent,
+            attrIndexOffset
+          );
+          CorridorGeometryLibrary_default.addAttribute(
+            bitangents,
+            bitangent,
+            attrIndexOffset + 3
+          );
+          CorridorGeometryLibrary_default.addAttribute(
+            bitangents,
+            bitangent,
+            attrIndex
+          );
+          CorridorGeometryLibrary_default.addAttribute(
+            bitangents,
+            bitangent,
+            attrIndex + 3
+          );
+        }
+        if (vertexFormat.tangent) {
+          tangent = Cartesian3_default.normalize(
+            Cartesian3_default.cross(bitangent, normal, tangent),
+            tangent
+          );
+          CorridorGeometryLibrary_default.addAttribute(
+            tangents,
+            tangent,
+            attrIndexOffset
+          );
+          CorridorGeometryLibrary_default.addAttribute(
+            tangents,
+            tangent,
+            attrIndexOffset + 3
+          );
+          CorridorGeometryLibrary_default.addAttribute(tangents, tangent, attrIndex);
+          CorridorGeometryLibrary_default.addAttribute(
+            tangents,
+            tangent,
+            attrIndex + 3
+          );
+        }
+      }
+      attrIndex += 6;
+    }
+    if (vertexFormat.normal) {
+      normals.set(topNormals);
+      for (i = 0; i < threeSize; i += 3) {
+        normals[i + threeSize] = -topNormals[i];
+        normals[i + threeSize + 1] = -topNormals[i + 1];
+        normals[i + threeSize + 2] = -topNormals[i + 2];
+      }
+      attributes.normal.values = normals;
+    } else {
+      attributes.normal = void 0;
+    }
+    if (vertexFormat.bitangent) {
+      bitangents.set(topBitangents);
+      bitangents.set(topBitangents, threeSize);
+      attributes.bitangent.values = bitangents;
+    } else {
+      attributes.bitangent = void 0;
+    }
+    if (vertexFormat.tangent) {
+      const topTangents = attributes.tangent.values;
+      tangents.set(topTangents);
+      tangents.set(topTangents, threeSize);
+      attributes.tangent.values = tangents;
+    }
+  }
+  if (vertexFormat.st) {
+    const topSt = attributes.st.values;
+    const st = new Float32Array(twoSize * 6);
+    st.set(topSt);
+    st.set(topSt, twoSize);
+    let index = twoSize * 2;
+    for (let j = 0; j < 2; j++) {
+      st[index++] = topSt[0];
+      st[index++] = topSt[1];
+      for (i = 2; i < twoSize; i += 2) {
+        const s = topSt[i];
+        const t = topSt[i + 1];
+        st[index++] = s;
+        st[index++] = t;
+        st[index++] = s;
+        st[index++] = t;
+      }
+      st[index++] = topSt[0];
+      st[index++] = topSt[1];
+    }
+    attributes.st.values = st;
+  }
+  return attributes;
+}
+function addWallPositions(positions, index, wallPositions) {
+  wallPositions[index++] = positions[0];
+  wallPositions[index++] = positions[1];
+  wallPositions[index++] = positions[2];
+  for (let i = 3; i < positions.length; i += 3) {
+    const x = positions[i];
+    const y = positions[i + 1];
+    const z = positions[i + 2];
+    wallPositions[index++] = x;
+    wallPositions[index++] = y;
+    wallPositions[index++] = z;
+    wallPositions[index++] = x;
+    wallPositions[index++] = y;
+    wallPositions[index++] = z;
+  }
+  wallPositions[index++] = positions[0];
+  wallPositions[index++] = positions[1];
+  wallPositions[index++] = positions[2];
+  return wallPositions;
+}
+function computePositionsExtruded(params, vertexFormat) {
+  const topVertexFormat = new VertexFormat_default({
+    position: vertexFormat.position,
+    normal: vertexFormat.normal || vertexFormat.bitangent || params.shadowVolume,
+    tangent: vertexFormat.tangent,
+    bitangent: vertexFormat.normal || vertexFormat.bitangent,
+    st: vertexFormat.st
+  });
+  const ellipsoid = params.ellipsoid;
+  const computedPositions = CorridorGeometryLibrary_default.computePositions(params);
+  const attr = combine(computedPositions, topVertexFormat, ellipsoid);
+  const height = params.height;
+  const extrudedHeight = params.extrudedHeight;
+  let attributes = attr.attributes;
+  const indices = attr.indices;
+  let positions = attributes.position.values;
+  let length = positions.length;
+  const newPositions = new Float64Array(length * 6);
+  let extrudedPositions = new Float64Array(length);
+  extrudedPositions.set(positions);
+  let wallPositions = new Float64Array(length * 4);
+  positions = PolygonPipeline_default.scaleToGeodeticHeight(
+    positions,
+    height,
+    ellipsoid
+  );
+  wallPositions = addWallPositions(positions, 0, wallPositions);
+  extrudedPositions = PolygonPipeline_default.scaleToGeodeticHeight(
+    extrudedPositions,
+    extrudedHeight,
+    ellipsoid
+  );
+  wallPositions = addWallPositions(
+    extrudedPositions,
+    length * 2,
+    wallPositions
+  );
+  newPositions.set(positions);
+  newPositions.set(extrudedPositions, length);
+  newPositions.set(wallPositions, length * 2);
+  attributes.position.values = newPositions;
+  attributes = extrudedAttributes(attributes, vertexFormat);
+  let i;
+  const size = length / 3;
+  if (params.shadowVolume) {
+    const topNormals = attributes.normal.values;
+    length = topNormals.length;
+    let extrudeNormals = new Float32Array(length * 6);
+    for (i = 0; i < length; i++) {
+      topNormals[i] = -topNormals[i];
+    }
+    extrudeNormals.set(topNormals, length);
+    extrudeNormals = addWallPositions(topNormals, length * 4, extrudeNormals);
+    attributes.extrudeDirection = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: extrudeNormals
+    });
+    if (!vertexFormat.normal) {
+      attributes.normal = void 0;
+    }
+  }
+  if (defined_default(params.offsetAttribute)) {
+    let applyOffset = new Uint8Array(size * 6);
+    if (params.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
+      applyOffset = applyOffset.fill(1, 0, size).fill(1, size * 2, size * 4);
+    } else {
+      const applyOffsetValue = params.offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+      applyOffset = applyOffset.fill(applyOffsetValue);
+    }
+    attributes.applyOffset = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: applyOffset
+    });
+  }
+  const iLength = indices.length;
+  const twoSize = size + size;
+  const newIndices = IndexDatatype_default.createTypedArray(
+    newPositions.length / 3,
+    iLength * 2 + twoSize * 3
+  );
+  newIndices.set(indices);
+  let index = iLength;
+  for (i = 0; i < iLength; i += 3) {
+    const v0 = indices[i];
+    const v1 = indices[i + 1];
+    const v2 = indices[i + 2];
+    newIndices[index++] = v2 + size;
+    newIndices[index++] = v1 + size;
+    newIndices[index++] = v0 + size;
+  }
+  let UL, LL, UR, LR;
+  for (i = 0; i < twoSize; i += 2) {
+    UL = i + twoSize;
+    LL = UL + twoSize;
+    UR = UL + 1;
+    LR = LL + 1;
+    newIndices[index++] = UL;
+    newIndices[index++] = LL;
+    newIndices[index++] = UR;
+    newIndices[index++] = UR;
+    newIndices[index++] = LL;
+    newIndices[index++] = LR;
+  }
+  return {
+    attributes,
+    indices: newIndices
+  };
+}
+var scratchCartesian1 = new Cartesian3_default();
+var scratchCartesian2 = new Cartesian3_default();
+var scratchCartographic = new Cartographic_default();
+function computeOffsetPoints(position1, position2, ellipsoid, halfWidth, min, max) {
+  const direction = Cartesian3_default.subtract(
+    position2,
+    position1,
+    scratchCartesian1
+  );
+  Cartesian3_default.normalize(direction, direction);
+  const normal = ellipsoid.geodeticSurfaceNormal(position1, scratchCartesian2);
+  const offsetDirection = Cartesian3_default.cross(
+    direction,
+    normal,
+    scratchCartesian1
+  );
+  Cartesian3_default.multiplyByScalar(offsetDirection, halfWidth, offsetDirection);
+  let minLat = min.latitude;
+  let minLon = min.longitude;
+  let maxLat = max.latitude;
+  let maxLon = max.longitude;
+  Cartesian3_default.add(position1, offsetDirection, scratchCartesian2);
+  ellipsoid.cartesianToCartographic(scratchCartesian2, scratchCartographic);
+  let lat = scratchCartographic.latitude;
+  let lon = scratchCartographic.longitude;
+  minLat = Math.min(minLat, lat);
+  minLon = Math.min(minLon, lon);
+  maxLat = Math.max(maxLat, lat);
+  maxLon = Math.max(maxLon, lon);
+  Cartesian3_default.subtract(position1, offsetDirection, scratchCartesian2);
+  ellipsoid.cartesianToCartographic(scratchCartesian2, scratchCartographic);
+  lat = scratchCartographic.latitude;
+  lon = scratchCartographic.longitude;
+  minLat = Math.min(minLat, lat);
+  minLon = Math.min(minLon, lon);
+  maxLat = Math.max(maxLat, lat);
+  maxLon = Math.max(maxLon, lon);
+  min.latitude = minLat;
+  min.longitude = minLon;
+  max.latitude = maxLat;
+  max.longitude = maxLon;
+}
+var scratchCartesianOffset = new Cartesian3_default();
+var scratchCartesianEnds = new Cartesian3_default();
+var scratchCartographicMin = new Cartographic_default();
+var scratchCartographicMax = new Cartographic_default();
+function computeRectangle(positions, ellipsoid, width, cornerType, result) {
+  positions = scaleToSurface(positions, ellipsoid);
+  const cleanPositions = arrayRemoveDuplicates_default(
+    positions,
+    Cartesian3_default.equalsEpsilon
+  );
+  const length = cleanPositions.length;
+  if (length < 2 || width <= 0) {
+    return new Rectangle_default();
+  }
+  const halfWidth = width * 0.5;
+  scratchCartographicMin.latitude = Number.POSITIVE_INFINITY;
+  scratchCartographicMin.longitude = Number.POSITIVE_INFINITY;
+  scratchCartographicMax.latitude = Number.NEGATIVE_INFINITY;
+  scratchCartographicMax.longitude = Number.NEGATIVE_INFINITY;
+  let lat, lon;
+  if (cornerType === CornerType_default.ROUNDED) {
+    const first = cleanPositions[0];
+    Cartesian3_default.subtract(first, cleanPositions[1], scratchCartesianOffset);
+    Cartesian3_default.normalize(scratchCartesianOffset, scratchCartesianOffset);
+    Cartesian3_default.multiplyByScalar(
+      scratchCartesianOffset,
+      halfWidth,
+      scratchCartesianOffset
+    );
+    Cartesian3_default.add(first, scratchCartesianOffset, scratchCartesianEnds);
+    ellipsoid.cartesianToCartographic(
+      scratchCartesianEnds,
+      scratchCartographic
+    );
+    lat = scratchCartographic.latitude;
+    lon = scratchCartographic.longitude;
+    scratchCartographicMin.latitude = Math.min(
+      scratchCartographicMin.latitude,
+      lat
+    );
+    scratchCartographicMin.longitude = Math.min(
+      scratchCartographicMin.longitude,
+      lon
+    );
+    scratchCartographicMax.latitude = Math.max(
+      scratchCartographicMax.latitude,
+      lat
+    );
+    scratchCartographicMax.longitude = Math.max(
+      scratchCartographicMax.longitude,
+      lon
+    );
+  }
+  for (let i = 0; i < length - 1; ++i) {
+    computeOffsetPoints(
+      cleanPositions[i],
+      cleanPositions[i + 1],
+      ellipsoid,
+      halfWidth,
+      scratchCartographicMin,
+      scratchCartographicMax
+    );
+  }
+  const last = cleanPositions[length - 1];
+  Cartesian3_default.subtract(last, cleanPositions[length - 2], scratchCartesianOffset);
+  Cartesian3_default.normalize(scratchCartesianOffset, scratchCartesianOffset);
+  Cartesian3_default.multiplyByScalar(
+    scratchCartesianOffset,
+    halfWidth,
+    scratchCartesianOffset
+  );
+  Cartesian3_default.add(last, scratchCartesianOffset, scratchCartesianEnds);
+  computeOffsetPoints(
+    last,
+    scratchCartesianEnds,
+    ellipsoid,
+    halfWidth,
+    scratchCartographicMin,
+    scratchCartographicMax
+  );
+  if (cornerType === CornerType_default.ROUNDED) {
+    ellipsoid.cartesianToCartographic(
+      scratchCartesianEnds,
+      scratchCartographic
+    );
+    lat = scratchCartographic.latitude;
+    lon = scratchCartographic.longitude;
+    scratchCartographicMin.latitude = Math.min(
+      scratchCartographicMin.latitude,
+      lat
+    );
+    scratchCartographicMin.longitude = Math.min(
+      scratchCartographicMin.longitude,
+      lon
+    );
+    scratchCartographicMax.latitude = Math.max(
+      scratchCartographicMax.latitude,
+      lat
+    );
+    scratchCartographicMax.longitude = Math.max(
+      scratchCartographicMax.longitude,
+      lon
+    );
+  }
+  const rectangle = defined_default(result) ? result : new Rectangle_default();
+  rectangle.north = scratchCartographicMax.latitude;
+  rectangle.south = scratchCartographicMin.latitude;
+  rectangle.east = scratchCartographicMax.longitude;
+  rectangle.west = scratchCartographicMin.longitude;
+  return rectangle;
+}
+function CorridorGeometry(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const positions = options.positions;
+  const width = options.width;
+  Check_default.defined("options.positions", positions);
+  Check_default.defined("options.width", width);
+  const height = defaultValue_default(options.height, 0);
+  const extrudedHeight = defaultValue_default(options.extrudedHeight, height);
+  this._positions = positions;
+  this._ellipsoid = Ellipsoid_default.clone(
+    defaultValue_default(options.ellipsoid, Ellipsoid_default.default)
+  );
+  this._vertexFormat = VertexFormat_default.clone(
+    defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT)
+  );
+  this._width = width;
+  this._height = Math.max(height, extrudedHeight);
+  this._extrudedHeight = Math.min(height, extrudedHeight);
+  this._cornerType = defaultValue_default(options.cornerType, CornerType_default.ROUNDED);
+  this._granularity = defaultValue_default(
+    options.granularity,
+    Math_default.RADIANS_PER_DEGREE
+  );
+  this._shadowVolume = defaultValue_default(options.shadowVolume, false);
+  this._workerName = "createCorridorGeometry";
+  this._offsetAttribute = options.offsetAttribute;
+  this._rectangle = void 0;
+  this.packedLength = 1 + positions.length * Cartesian3_default.packedLength + Ellipsoid_default.packedLength + VertexFormat_default.packedLength + 7;
+}
+CorridorGeometry.pack = function(value, array, startingIndex) {
+  Check_default.defined("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const positions = value._positions;
+  const length = positions.length;
+  array[startingIndex++] = length;
+  for (let i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
+    Cartesian3_default.pack(positions[i], array, startingIndex);
+  }
+  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
+  startingIndex += Ellipsoid_default.packedLength;
+  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
+  startingIndex += VertexFormat_default.packedLength;
+  array[startingIndex++] = value._width;
+  array[startingIndex++] = value._height;
+  array[startingIndex++] = value._extrudedHeight;
+  array[startingIndex++] = value._cornerType;
+  array[startingIndex++] = value._granularity;
+  array[startingIndex++] = value._shadowVolume ? 1 : 0;
+  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
+  return array;
+};
+var scratchEllipsoid = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
+var scratchVertexFormat = new VertexFormat_default();
+var scratchOptions = {
+  positions: void 0,
+  ellipsoid: scratchEllipsoid,
+  vertexFormat: scratchVertexFormat,
+  width: void 0,
+  height: void 0,
+  extrudedHeight: void 0,
+  cornerType: void 0,
+  granularity: void 0,
+  shadowVolume: void 0,
+  offsetAttribute: void 0
+};
+CorridorGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const length = array[startingIndex++];
+  const positions = new Array(length);
+  for (let i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
+    positions[i] = Cartesian3_default.unpack(array, startingIndex);
+  }
+  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
+  startingIndex += Ellipsoid_default.packedLength;
+  const vertexFormat = VertexFormat_default.unpack(
+    array,
+    startingIndex,
+    scratchVertexFormat
+  );
+  startingIndex += VertexFormat_default.packedLength;
+  const width = array[startingIndex++];
+  const height = array[startingIndex++];
+  const extrudedHeight = array[startingIndex++];
+  const cornerType = array[startingIndex++];
+  const granularity = array[startingIndex++];
+  const shadowVolume = array[startingIndex++] === 1;
+  const offsetAttribute = array[startingIndex];
+  if (!defined_default(result)) {
+    scratchOptions.positions = positions;
+    scratchOptions.width = width;
+    scratchOptions.height = height;
+    scratchOptions.extrudedHeight = extrudedHeight;
+    scratchOptions.cornerType = cornerType;
+    scratchOptions.granularity = granularity;
+    scratchOptions.shadowVolume = shadowVolume;
+    scratchOptions.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+    return new CorridorGeometry(scratchOptions);
+  }
+  result._positions = positions;
+  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
+  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
+  result._width = width;
+  result._height = height;
+  result._extrudedHeight = extrudedHeight;
+  result._cornerType = cornerType;
+  result._granularity = granularity;
+  result._shadowVolume = shadowVolume;
+  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+  return result;
+};
+CorridorGeometry.computeRectangle = function(options, result) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const positions = options.positions;
+  const width = options.width;
+  Check_default.defined("options.positions", positions);
+  Check_default.defined("options.width", width);
+  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.default);
+  const cornerType = defaultValue_default(options.cornerType, CornerType_default.ROUNDED);
+  return computeRectangle(positions, ellipsoid, width, cornerType, result);
+};
+CorridorGeometry.createGeometry = function(corridorGeometry) {
+  let positions = corridorGeometry._positions;
+  const width = corridorGeometry._width;
+  const ellipsoid = corridorGeometry._ellipsoid;
+  positions = scaleToSurface(positions, ellipsoid);
+  const cleanPositions = arrayRemoveDuplicates_default(
+    positions,
+    Cartesian3_default.equalsEpsilon
+  );
+  if (cleanPositions.length < 2 || width <= 0) {
+    return;
+  }
+  const height = corridorGeometry._height;
+  const extrudedHeight = corridorGeometry._extrudedHeight;
+  const extrude = !Math_default.equalsEpsilon(
+    height,
+    extrudedHeight,
+    0,
+    Math_default.EPSILON2
+  );
+  const vertexFormat = corridorGeometry._vertexFormat;
+  const params = {
+    ellipsoid,
+    positions: cleanPositions,
+    width,
+    cornerType: corridorGeometry._cornerType,
+    granularity: corridorGeometry._granularity,
+    saveAttributes: true
+  };
+  let attr;
+  if (extrude) {
+    params.height = height;
+    params.extrudedHeight = extrudedHeight;
+    params.shadowVolume = corridorGeometry._shadowVolume;
+    params.offsetAttribute = corridorGeometry._offsetAttribute;
+    attr = computePositionsExtruded(params, vertexFormat);
+  } else {
+    const computedPositions = CorridorGeometryLibrary_default.computePositions(params);
+    attr = combine(computedPositions, vertexFormat, ellipsoid);
+    attr.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
+      attr.attributes.position.values,
+      height,
+      ellipsoid
+    );
+    if (defined_default(corridorGeometry._offsetAttribute)) {
+      const applyOffsetValue = corridorGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+      const length = attr.attributes.position.values.length;
+      const applyOffset = new Uint8Array(length / 3).fill(applyOffsetValue);
+      attr.attributes.applyOffset = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+        componentsPerAttribute: 1,
+        values: applyOffset
+      });
+    }
+  }
+  const attributes = attr.attributes;
+  const boundingSphere = BoundingSphere_default.fromVertices(
+    attributes.position.values,
+    void 0,
+    3
+  );
+  if (!vertexFormat.position) {
+    attr.attributes.position.values = void 0;
+  }
+  return new Geometry_default({
+    attributes,
+    indices: attr.indices,
+    primitiveType: PrimitiveType_default.TRIANGLES,
+    boundingSphere,
+    offsetAttribute: corridorGeometry._offsetAttribute
+  });
+};
+CorridorGeometry.createShadowVolume = function(corridorGeometry, minHeightFunc, maxHeightFunc) {
+  const granularity = corridorGeometry._granularity;
+  const ellipsoid = corridorGeometry._ellipsoid;
+  const minHeight = minHeightFunc(granularity, ellipsoid);
+  const maxHeight = maxHeightFunc(granularity, ellipsoid);
+  return new CorridorGeometry({
+    positions: corridorGeometry._positions,
+    width: corridorGeometry._width,
+    cornerType: corridorGeometry._cornerType,
+    ellipsoid,
+    granularity,
+    extrudedHeight: minHeight,
+    height: maxHeight,
+    vertexFormat: VertexFormat_default.POSITION_ONLY,
+    shadowVolume: true
+  });
+};
+Object.defineProperties(CorridorGeometry.prototype, {
+  /**
+   * @private
+   */
+  rectangle: {
+    get: function() {
+      if (!defined_default(this._rectangle)) {
+        this._rectangle = computeRectangle(
+          this._positions,
+          this._ellipsoid,
+          this._width,
+          this._cornerType
+        );
+      }
+      return this._rectangle;
+    }
+  },
+  /**
+   * For remapping texture coordinates when rendering CorridorGeometries as GroundPrimitives.
+   *
+   * Corridors don't support stRotation,
+   * so just return the corners of the original system.
+   * @private
+   */
+  textureCoordinateRotationPoints: {
+    get: function() {
+      return [0, 0, 0, 1, 1, 0];
+    }
+  }
+});
+var CorridorGeometry_default = CorridorGeometry;
+
+// packages/engine/Source/Workers/createCorridorGeometry.js
+function createCorridorGeometry(corridorGeometry, offset) {
+  if (defined_default(offset)) {
+    corridorGeometry = CorridorGeometry_default.unpack(corridorGeometry, offset);
+  }
+  corridorGeometry._ellipsoid = Ellipsoid_default.clone(corridorGeometry._ellipsoid);
+  return CorridorGeometry_default.createGeometry(corridorGeometry);
+}
+var createCorridorGeometry_default = createCorridorGeometry;
+export {
+  createCorridorGeometry_default as default
+};

public/assets/cesium/Workers/createCorridorOutlineGeometry.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 {
+  CorridorGeometryLibrary_default
+} from "./chunk-EJVGYGLF.js";
+import {
+  CornerType_default
+} from "./chunk-3IFRSGEY.js";
+import "./chunk-QN6TBED4.js";
+import "./chunk-C3EQ27WF.js";
+import {
+  GeometryOffsetAttribute_default
+} from "./chunk-GBT7MJ6X.js";
+import "./chunk-YK3QIKY7.js";
+import "./chunk-NDDI2LWR.js";
+import {
+  PolygonPipeline_default
+} from "./chunk-TI3TRKIC.js";
+import {
+  arrayRemoveDuplicates_default
+} from "./chunk-57H6I3SV.js";
+import "./chunk-JSQJDZI4.js";
+import "./chunk-QQOZO7KO.js";
+import "./chunk-EDLRS3AW.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 "./chunk-6SQMLVGV.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 "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.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/CorridorOutlineGeometry.js
+var cartesian1 = new Cartesian3_default();
+var cartesian2 = new Cartesian3_default();
+var cartesian3 = new Cartesian3_default();
+function scaleToSurface(positions, ellipsoid) {
+  for (let i = 0; i < positions.length; i++) {
+    positions[i] = ellipsoid.scaleToGeodeticSurface(positions[i], positions[i]);
+  }
+  return positions;
+}
+function combine(computedPositions, cornerType) {
+  const wallIndices = [];
+  const positions = computedPositions.positions;
+  const corners = computedPositions.corners;
+  const endPositions = computedPositions.endPositions;
+  const attributes = new GeometryAttributes_default();
+  let corner;
+  let leftCount = 0;
+  let rightCount = 0;
+  let i;
+  let indicesLength = 0;
+  let length;
+  for (i = 0; i < positions.length; i += 2) {
+    length = positions[i].length - 3;
+    leftCount += length;
+    indicesLength += length / 3 * 4;
+    rightCount += positions[i + 1].length - 3;
+  }
+  leftCount += 3;
+  rightCount += 3;
+  for (i = 0; i < corners.length; i++) {
+    corner = corners[i];
+    const leftSide = corners[i].leftPositions;
+    if (defined_default(leftSide)) {
+      length = leftSide.length;
+      leftCount += length;
+      indicesLength += length / 3 * 2;
+    } else {
+      length = corners[i].rightPositions.length;
+      rightCount += length;
+      indicesLength += length / 3 * 2;
+    }
+  }
+  const addEndPositions = defined_default(endPositions);
+  let endPositionLength;
+  if (addEndPositions) {
+    endPositionLength = endPositions[0].length - 3;
+    leftCount += endPositionLength;
+    rightCount += endPositionLength;
+    endPositionLength /= 3;
+    indicesLength += endPositionLength * 4;
+  }
+  const size = leftCount + rightCount;
+  const finalPositions = new Float64Array(size);
+  let front = 0;
+  let back = size - 1;
+  let UL, LL, UR, LR;
+  let rightPos, leftPos;
+  const halfLength = endPositionLength / 2;
+  const indices = IndexDatatype_default.createTypedArray(size / 3, indicesLength + 4);
+  let index = 0;
+  indices[index++] = front / 3;
+  indices[index++] = (back - 2) / 3;
+  if (addEndPositions) {
+    wallIndices.push(front / 3);
+    leftPos = cartesian1;
+    rightPos = cartesian2;
+    const firstEndPositions = endPositions[0];
+    for (i = 0; i < halfLength; i++) {
+      leftPos = Cartesian3_default.fromArray(
+        firstEndPositions,
+        (halfLength - 1 - i) * 3,
+        leftPos
+      );
+      rightPos = Cartesian3_default.fromArray(
+        firstEndPositions,
+        (halfLength + i) * 3,
+        rightPos
+      );
+      CorridorGeometryLibrary_default.addAttribute(finalPositions, rightPos, front);
+      CorridorGeometryLibrary_default.addAttribute(
+        finalPositions,
+        leftPos,
+        void 0,
+        back
+      );
+      LL = front / 3;
+      LR = LL + 1;
+      UL = (back - 2) / 3;
+      UR = UL - 1;
+      indices[index++] = UL;
+      indices[index++] = UR;
+      indices[index++] = LL;
+      indices[index++] = LR;
+      front += 3;
+      back -= 3;
+    }
+  }
+  let posIndex = 0;
+  let rightEdge = positions[posIndex++];
+  let leftEdge = positions[posIndex++];
+  finalPositions.set(rightEdge, front);
+  finalPositions.set(leftEdge, back - leftEdge.length + 1);
+  length = leftEdge.length - 3;
+  wallIndices.push(front / 3, (back - 2) / 3);
+  for (i = 0; i < length; i += 3) {
+    LL = front / 3;
+    LR = LL + 1;
+    UL = (back - 2) / 3;
+    UR = UL - 1;
+    indices[index++] = UL;
+    indices[index++] = UR;
+    indices[index++] = LL;
+    indices[index++] = LR;
+    front += 3;
+    back -= 3;
+  }
+  for (i = 0; i < corners.length; i++) {
+    let j;
+    corner = corners[i];
+    const l = corner.leftPositions;
+    const r = corner.rightPositions;
+    let start;
+    let outsidePoint = cartesian3;
+    if (defined_default(l)) {
+      back -= 3;
+      start = UR;
+      wallIndices.push(LR);
+      for (j = 0; j < l.length / 3; j++) {
+        outsidePoint = Cartesian3_default.fromArray(l, j * 3, outsidePoint);
+        indices[index++] = start - j - 1;
+        indices[index++] = start - j;
+        CorridorGeometryLibrary_default.addAttribute(
+          finalPositions,
+          outsidePoint,
+          void 0,
+          back
+        );
+        back -= 3;
+      }
+      wallIndices.push(start - Math.floor(l.length / 6));
+      if (cornerType === CornerType_default.BEVELED) {
+        wallIndices.push((back - 2) / 3 + 1);
+      }
+      front += 3;
+    } else {
+      front += 3;
+      start = LR;
+      wallIndices.push(UR);
+      for (j = 0; j < r.length / 3; j++) {
+        outsidePoint = Cartesian3_default.fromArray(r, j * 3, outsidePoint);
+        indices[index++] = start + j;
+        indices[index++] = start + j + 1;
+        CorridorGeometryLibrary_default.addAttribute(
+          finalPositions,
+          outsidePoint,
+          front
+        );
+        front += 3;
+      }
+      wallIndices.push(start + Math.floor(r.length / 6));
+      if (cornerType === CornerType_default.BEVELED) {
+        wallIndices.push(front / 3 - 1);
+      }
+      back -= 3;
+    }
+    rightEdge = positions[posIndex++];
+    leftEdge = positions[posIndex++];
+    rightEdge.splice(0, 3);
+    leftEdge.splice(leftEdge.length - 3, 3);
+    finalPositions.set(rightEdge, front);
+    finalPositions.set(leftEdge, back - leftEdge.length + 1);
+    length = leftEdge.length - 3;
+    for (j = 0; j < leftEdge.length; j += 3) {
+      LR = front / 3;
+      LL = LR - 1;
+      UR = (back - 2) / 3;
+      UL = UR + 1;
+      indices[index++] = UL;
+      indices[index++] = UR;
+      indices[index++] = LL;
+      indices[index++] = LR;
+      front += 3;
+      back -= 3;
+    }
+    front -= 3;
+    back += 3;
+    wallIndices.push(front / 3, (back - 2) / 3);
+  }
+  if (addEndPositions) {
+    front += 3;
+    back -= 3;
+    leftPos = cartesian1;
+    rightPos = cartesian2;
+    const lastEndPositions = endPositions[1];
+    for (i = 0; i < halfLength; i++) {
+      leftPos = Cartesian3_default.fromArray(
+        lastEndPositions,
+        (endPositionLength - i - 1) * 3,
+        leftPos
+      );
+      rightPos = Cartesian3_default.fromArray(lastEndPositions, i * 3, rightPos);
+      CorridorGeometryLibrary_default.addAttribute(
+        finalPositions,
+        leftPos,
+        void 0,
+        back
+      );
+      CorridorGeometryLibrary_default.addAttribute(finalPositions, rightPos, front);
+      LR = front / 3;
+      LL = LR - 1;
+      UR = (back - 2) / 3;
+      UL = UR + 1;
+      indices[index++] = UL;
+      indices[index++] = UR;
+      indices[index++] = LL;
+      indices[index++] = LR;
+      front += 3;
+      back -= 3;
+    }
+    wallIndices.push(front / 3);
+  } else {
+    wallIndices.push(front / 3, (back - 2) / 3);
+  }
+  indices[index++] = front / 3;
+  indices[index++] = (back - 2) / 3;
+  attributes.position = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.DOUBLE,
+    componentsPerAttribute: 3,
+    values: finalPositions
+  });
+  return {
+    attributes,
+    indices,
+    wallIndices
+  };
+}
+function computePositionsExtruded(params) {
+  const ellipsoid = params.ellipsoid;
+  const computedPositions = CorridorGeometryLibrary_default.computePositions(params);
+  const attr = combine(computedPositions, params.cornerType);
+  const wallIndices = attr.wallIndices;
+  const height = params.height;
+  const extrudedHeight = params.extrudedHeight;
+  const attributes = attr.attributes;
+  const indices = attr.indices;
+  let positions = attributes.position.values;
+  let length = positions.length;
+  let extrudedPositions = new Float64Array(length);
+  extrudedPositions.set(positions);
+  const newPositions = new Float64Array(length * 2);
+  positions = PolygonPipeline_default.scaleToGeodeticHeight(
+    positions,
+    height,
+    ellipsoid
+  );
+  extrudedPositions = PolygonPipeline_default.scaleToGeodeticHeight(
+    extrudedPositions,
+    extrudedHeight,
+    ellipsoid
+  );
+  newPositions.set(positions);
+  newPositions.set(extrudedPositions, length);
+  attributes.position.values = newPositions;
+  length /= 3;
+  if (defined_default(params.offsetAttribute)) {
+    let applyOffset = new Uint8Array(length * 2);
+    if (params.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
+      applyOffset = applyOffset.fill(1, 0, length);
+    } else {
+      const applyOffsetValue = params.offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+      applyOffset = applyOffset.fill(applyOffsetValue);
+    }
+    attributes.applyOffset = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: applyOffset
+    });
+  }
+  let i;
+  const iLength = indices.length;
+  const newIndices = IndexDatatype_default.createTypedArray(
+    newPositions.length / 3,
+    (iLength + wallIndices.length) * 2
+  );
+  newIndices.set(indices);
+  let index = iLength;
+  for (i = 0; i < iLength; i += 2) {
+    const v0 = indices[i];
+    const v1 = indices[i + 1];
+    newIndices[index++] = v0 + length;
+    newIndices[index++] = v1 + length;
+  }
+  let UL, LL;
+  for (i = 0; i < wallIndices.length; i++) {
+    UL = wallIndices[i];
+    LL = UL + length;
+    newIndices[index++] = UL;
+    newIndices[index++] = LL;
+  }
+  return {
+    attributes,
+    indices: newIndices
+  };
+}
+function CorridorOutlineGeometry(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const positions = options.positions;
+  const width = options.width;
+  Check_default.typeOf.object("options.positions", positions);
+  Check_default.typeOf.number("options.width", width);
+  const height = defaultValue_default(options.height, 0);
+  const extrudedHeight = defaultValue_default(options.extrudedHeight, height);
+  this._positions = positions;
+  this._ellipsoid = Ellipsoid_default.clone(
+    defaultValue_default(options.ellipsoid, Ellipsoid_default.default)
+  );
+  this._width = width;
+  this._height = Math.max(height, extrudedHeight);
+  this._extrudedHeight = Math.min(height, extrudedHeight);
+  this._cornerType = defaultValue_default(options.cornerType, CornerType_default.ROUNDED);
+  this._granularity = defaultValue_default(
+    options.granularity,
+    Math_default.RADIANS_PER_DEGREE
+  );
+  this._offsetAttribute = options.offsetAttribute;
+  this._workerName = "createCorridorOutlineGeometry";
+  this.packedLength = 1 + positions.length * Cartesian3_default.packedLength + Ellipsoid_default.packedLength + 6;
+}
+CorridorOutlineGeometry.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.typeOf.object("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const positions = value._positions;
+  const length = positions.length;
+  array[startingIndex++] = length;
+  for (let i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
+    Cartesian3_default.pack(positions[i], array, startingIndex);
+  }
+  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
+  startingIndex += Ellipsoid_default.packedLength;
+  array[startingIndex++] = value._width;
+  array[startingIndex++] = value._height;
+  array[startingIndex++] = value._extrudedHeight;
+  array[startingIndex++] = value._cornerType;
+  array[startingIndex++] = value._granularity;
+  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
+  return array;
+};
+var scratchEllipsoid = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
+var scratchOptions = {
+  positions: void 0,
+  ellipsoid: scratchEllipsoid,
+  width: void 0,
+  height: void 0,
+  extrudedHeight: void 0,
+  cornerType: void 0,
+  granularity: void 0,
+  offsetAttribute: void 0
+};
+CorridorOutlineGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.typeOf.object("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const length = array[startingIndex++];
+  const positions = new Array(length);
+  for (let i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
+    positions[i] = Cartesian3_default.unpack(array, startingIndex);
+  }
+  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
+  startingIndex += Ellipsoid_default.packedLength;
+  const width = array[startingIndex++];
+  const height = array[startingIndex++];
+  const extrudedHeight = array[startingIndex++];
+  const cornerType = array[startingIndex++];
+  const granularity = array[startingIndex++];
+  const offsetAttribute = array[startingIndex];
+  if (!defined_default(result)) {
+    scratchOptions.positions = positions;
+    scratchOptions.width = width;
+    scratchOptions.height = height;
+    scratchOptions.extrudedHeight = extrudedHeight;
+    scratchOptions.cornerType = cornerType;
+    scratchOptions.granularity = granularity;
+    scratchOptions.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+    return new CorridorOutlineGeometry(scratchOptions);
+  }
+  result._positions = positions;
+  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
+  result._width = width;
+  result._height = height;
+  result._extrudedHeight = extrudedHeight;
+  result._cornerType = cornerType;
+  result._granularity = granularity;
+  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+  return result;
+};
+CorridorOutlineGeometry.createGeometry = function(corridorOutlineGeometry) {
+  let positions = corridorOutlineGeometry._positions;
+  const width = corridorOutlineGeometry._width;
+  const ellipsoid = corridorOutlineGeometry._ellipsoid;
+  positions = scaleToSurface(positions, ellipsoid);
+  const cleanPositions = arrayRemoveDuplicates_default(
+    positions,
+    Cartesian3_default.equalsEpsilon
+  );
+  if (cleanPositions.length < 2 || width <= 0) {
+    return;
+  }
+  const height = corridorOutlineGeometry._height;
+  const extrudedHeight = corridorOutlineGeometry._extrudedHeight;
+  const extrude = !Math_default.equalsEpsilon(
+    height,
+    extrudedHeight,
+    0,
+    Math_default.EPSILON2
+  );
+  const params = {
+    ellipsoid,
+    positions: cleanPositions,
+    width,
+    cornerType: corridorOutlineGeometry._cornerType,
+    granularity: corridorOutlineGeometry._granularity,
+    saveAttributes: false
+  };
+  let attr;
+  if (extrude) {
+    params.height = height;
+    params.extrudedHeight = extrudedHeight;
+    params.offsetAttribute = corridorOutlineGeometry._offsetAttribute;
+    attr = computePositionsExtruded(params);
+  } else {
+    const computedPositions = CorridorGeometryLibrary_default.computePositions(params);
+    attr = combine(computedPositions, params.cornerType);
+    attr.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
+      attr.attributes.position.values,
+      height,
+      ellipsoid
+    );
+    if (defined_default(corridorOutlineGeometry._offsetAttribute)) {
+      const length = attr.attributes.position.values.length;
+      const offsetValue = corridorOutlineGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+      const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
+      attr.attributes.applyOffset = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+        componentsPerAttribute: 1,
+        values: applyOffset
+      });
+    }
+  }
+  const attributes = attr.attributes;
+  const boundingSphere = BoundingSphere_default.fromVertices(
+    attributes.position.values,
+    void 0,
+    3
+  );
+  return new Geometry_default({
+    attributes,
+    indices: attr.indices,
+    primitiveType: PrimitiveType_default.LINES,
+    boundingSphere,
+    offsetAttribute: corridorOutlineGeometry._offsetAttribute
+  });
+};
+var CorridorOutlineGeometry_default = CorridorOutlineGeometry;
+
+// packages/engine/Source/Workers/createCorridorOutlineGeometry.js
+function createCorridorOutlineGeometry(corridorOutlineGeometry, offset) {
+  if (defined_default(offset)) {
+    corridorOutlineGeometry = CorridorOutlineGeometry_default.unpack(
+      corridorOutlineGeometry,
+      offset
+    );
+  }
+  corridorOutlineGeometry._ellipsoid = Ellipsoid_default.clone(
+    corridorOutlineGeometry._ellipsoid
+  );
+  return CorridorOutlineGeometry_default.createGeometry(corridorOutlineGeometry);
+}
+var createCorridorOutlineGeometry_default = createCorridorOutlineGeometry;
+export {
+  createCorridorOutlineGeometry_default as default
+};

public/assets/cesium/Workers/createCylinderGeometry.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 {
+  CylinderGeometry_default
+} from "./chunk-L5GODJAR.js";
+import "./chunk-O72GZTSE.js";
+import "./chunk-GBT7MJ6X.js";
+import "./chunk-JBSKHTNX.js";
+import "./chunk-C4WPMOKT.js";
+import "./chunk-X7IQYYHF.js";
+import "./chunk-JXVLNVXC.js";
+import "./chunk-KHZNBFOH.js";
+import "./chunk-6SQMLVGV.js";
+import "./chunk-XIUSRWL6.js";
+import "./chunk-FFLMY4TE.js";
+import "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.js";
+import "./chunk-U5HSOKPQ.js";
+import "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Workers/createCylinderGeometry.js
+function createCylinderGeometry(cylinderGeometry, offset) {
+  if (defined_default(offset)) {
+    cylinderGeometry = CylinderGeometry_default.unpack(cylinderGeometry, offset);
+  }
+  return CylinderGeometry_default.createGeometry(cylinderGeometry);
+}
+var createCylinderGeometry_default = createCylinderGeometry;
+export {
+  createCylinderGeometry_default as default
+};

public/assets/cesium/Workers/createCylinderOutlineGeometry.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 {
+  CylinderGeometryLibrary_default
+} from "./chunk-O72GZTSE.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 "./chunk-6SQMLVGV.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian2_default,
+  Cartesian3_default
+} from "./chunk-FFLMY4TE.js";
+import "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.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/CylinderOutlineGeometry.js
+var radiusScratch = new Cartesian2_default();
+function CylinderOutlineGeometry(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const length = options.length;
+  const topRadius = options.topRadius;
+  const bottomRadius = options.bottomRadius;
+  const slices = defaultValue_default(options.slices, 128);
+  const numberOfVerticalLines = Math.max(
+    defaultValue_default(options.numberOfVerticalLines, 16),
+    0
+  );
+  Check_default.typeOf.number("options.positions", length);
+  Check_default.typeOf.number("options.topRadius", topRadius);
+  Check_default.typeOf.number("options.bottomRadius", bottomRadius);
+  Check_default.typeOf.number.greaterThanOrEquals("options.slices", slices, 3);
+  if (defined_default(options.offsetAttribute) && options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
+    throw new DeveloperError_default(
+      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry."
+    );
+  }
+  this._length = length;
+  this._topRadius = topRadius;
+  this._bottomRadius = bottomRadius;
+  this._slices = slices;
+  this._numberOfVerticalLines = numberOfVerticalLines;
+  this._offsetAttribute = options.offsetAttribute;
+  this._workerName = "createCylinderOutlineGeometry";
+}
+CylinderOutlineGeometry.packedLength = 6;
+CylinderOutlineGeometry.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  array[startingIndex++] = value._length;
+  array[startingIndex++] = value._topRadius;
+  array[startingIndex++] = value._bottomRadius;
+  array[startingIndex++] = value._slices;
+  array[startingIndex++] = value._numberOfVerticalLines;
+  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
+  return array;
+};
+var scratchOptions = {
+  length: void 0,
+  topRadius: void 0,
+  bottomRadius: void 0,
+  slices: void 0,
+  numberOfVerticalLines: void 0,
+  offsetAttribute: void 0
+};
+CylinderOutlineGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const length = array[startingIndex++];
+  const topRadius = array[startingIndex++];
+  const bottomRadius = array[startingIndex++];
+  const slices = array[startingIndex++];
+  const numberOfVerticalLines = array[startingIndex++];
+  const offsetAttribute = array[startingIndex];
+  if (!defined_default(result)) {
+    scratchOptions.length = length;
+    scratchOptions.topRadius = topRadius;
+    scratchOptions.bottomRadius = bottomRadius;
+    scratchOptions.slices = slices;
+    scratchOptions.numberOfVerticalLines = numberOfVerticalLines;
+    scratchOptions.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+    return new CylinderOutlineGeometry(scratchOptions);
+  }
+  result._length = length;
+  result._topRadius = topRadius;
+  result._bottomRadius = bottomRadius;
+  result._slices = slices;
+  result._numberOfVerticalLines = numberOfVerticalLines;
+  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+  return result;
+};
+CylinderOutlineGeometry.createGeometry = function(cylinderGeometry) {
+  let length = cylinderGeometry._length;
+  const topRadius = cylinderGeometry._topRadius;
+  const bottomRadius = cylinderGeometry._bottomRadius;
+  const slices = cylinderGeometry._slices;
+  const numberOfVerticalLines = cylinderGeometry._numberOfVerticalLines;
+  if (length <= 0 || topRadius < 0 || bottomRadius < 0 || topRadius === 0 && bottomRadius === 0) {
+    return;
+  }
+  const numVertices = slices * 2;
+  const positions = CylinderGeometryLibrary_default.computePositions(
+    length,
+    topRadius,
+    bottomRadius,
+    slices,
+    false
+  );
+  let numIndices = slices * 2;
+  let numSide;
+  if (numberOfVerticalLines > 0) {
+    const numSideLines = Math.min(numberOfVerticalLines, slices);
+    numSide = Math.round(slices / numSideLines);
+    numIndices += numSideLines;
+  }
+  const indices = IndexDatatype_default.createTypedArray(numVertices, numIndices * 2);
+  let index = 0;
+  let i;
+  for (i = 0; i < slices - 1; i++) {
+    indices[index++] = i;
+    indices[index++] = i + 1;
+    indices[index++] = i + slices;
+    indices[index++] = i + 1 + slices;
+  }
+  indices[index++] = slices - 1;
+  indices[index++] = 0;
+  indices[index++] = slices + slices - 1;
+  indices[index++] = slices;
+  if (numberOfVerticalLines > 0) {
+    for (i = 0; i < slices; i += numSide) {
+      indices[index++] = i;
+      indices[index++] = i + slices;
+    }
+  }
+  const attributes = new GeometryAttributes_default();
+  attributes.position = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.DOUBLE,
+    componentsPerAttribute: 3,
+    values: positions
+  });
+  radiusScratch.x = length * 0.5;
+  radiusScratch.y = Math.max(bottomRadius, topRadius);
+  const boundingSphere = new BoundingSphere_default(
+    Cartesian3_default.ZERO,
+    Cartesian2_default.magnitude(radiusScratch)
+  );
+  if (defined_default(cylinderGeometry._offsetAttribute)) {
+    length = positions.length;
+    const offsetValue = cylinderGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+    const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
+    attributes.applyOffset = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: applyOffset
+    });
+  }
+  return new Geometry_default({
+    attributes,
+    indices,
+    primitiveType: PrimitiveType_default.LINES,
+    boundingSphere,
+    offsetAttribute: cylinderGeometry._offsetAttribute
+  });
+};
+var CylinderOutlineGeometry_default = CylinderOutlineGeometry;
+
+// packages/engine/Source/Workers/createCylinderOutlineGeometry.js
+function createCylinderOutlineGeometry(cylinderGeometry, offset) {
+  if (defined_default(offset)) {
+    cylinderGeometry = CylinderOutlineGeometry_default.unpack(cylinderGeometry, offset);
+  }
+  return CylinderOutlineGeometry_default.createGeometry(cylinderGeometry);
+}
+var createCylinderOutlineGeometry_default = createCylinderOutlineGeometry;
+export {
+  createCylinderOutlineGeometry_default as default
+};

public/assets/cesium/Workers/createEllipseGeometry.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 {
+  EllipseGeometry_default
+} from "./chunk-ZVUUPJEM.js";
+import "./chunk-JISPSEF3.js";
+import "./chunk-YSIJTJ7N.js";
+import "./chunk-7ZZ5LMZY.js";
+import "./chunk-LJ2JQHJT.js";
+import "./chunk-NGZJIN5Z.js";
+import "./chunk-GBT7MJ6X.js";
+import "./chunk-JBSKHTNX.js";
+import "./chunk-QQOZO7KO.js";
+import "./chunk-EDLRS3AW.js";
+import "./chunk-C4WPMOKT.js";
+import "./chunk-X7IQYYHF.js";
+import "./chunk-JXVLNVXC.js";
+import "./chunk-KHZNBFOH.js";
+import "./chunk-6SQMLVGV.js";
+import "./chunk-XIUSRWL6.js";
+import {
+  Cartesian3_default,
+  Ellipsoid_default
+} from "./chunk-FFLMY4TE.js";
+import "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.js";
+import "./chunk-U5HSOKPQ.js";
+import "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Workers/createEllipseGeometry.js
+function createEllipseGeometry(ellipseGeometry, offset) {
+  if (defined_default(offset)) {
+    ellipseGeometry = EllipseGeometry_default.unpack(ellipseGeometry, offset);
+  }
+  ellipseGeometry._center = Cartesian3_default.clone(ellipseGeometry._center);
+  ellipseGeometry._ellipsoid = Ellipsoid_default.clone(ellipseGeometry._ellipsoid);
+  return EllipseGeometry_default.createGeometry(ellipseGeometry);
+}
+var createEllipseGeometry_default = createEllipseGeometry;
+export {
+  createEllipseGeometry_default as default
+};

public/assets/cesium/Workers/createEllipseOutlineGeometry.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 {
+  EllipseOutlineGeometry_default
+} from "./chunk-2LOWCAMW.js";
+import "./chunk-JISPSEF3.js";
+import "./chunk-GBT7MJ6X.js";
+import "./chunk-C4WPMOKT.js";
+import "./chunk-X7IQYYHF.js";
+import "./chunk-JXVLNVXC.js";
+import "./chunk-KHZNBFOH.js";
+import "./chunk-6SQMLVGV.js";
+import "./chunk-XIUSRWL6.js";
+import {
+  Cartesian3_default,
+  Ellipsoid_default
+} from "./chunk-FFLMY4TE.js";
+import "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.js";
+import "./chunk-U5HSOKPQ.js";
+import "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Workers/createEllipseOutlineGeometry.js
+function createEllipseOutlineGeometry(ellipseGeometry, offset) {
+  if (defined_default(offset)) {
+    ellipseGeometry = EllipseOutlineGeometry_default.unpack(ellipseGeometry, offset);
+  }
+  ellipseGeometry._center = Cartesian3_default.clone(ellipseGeometry._center);
+  ellipseGeometry._ellipsoid = Ellipsoid_default.clone(ellipseGeometry._ellipsoid);
+  return EllipseOutlineGeometry_default.createGeometry(ellipseGeometry);
+}
+var createEllipseOutlineGeometry_default = createEllipseOutlineGeometry;
+export {
+  createEllipseOutlineGeometry_default as default
+};

public/assets/cesium/Workers/createEllipsoidGeometry.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 {
+  EllipsoidGeometry_default
+} from "./chunk-IZGUQO6Q.js";
+import "./chunk-GBT7MJ6X.js";
+import "./chunk-JBSKHTNX.js";
+import "./chunk-C4WPMOKT.js";
+import "./chunk-X7IQYYHF.js";
+import "./chunk-JXVLNVXC.js";
+import "./chunk-KHZNBFOH.js";
+import "./chunk-6SQMLVGV.js";
+import "./chunk-XIUSRWL6.js";
+import "./chunk-FFLMY4TE.js";
+import "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.js";
+import "./chunk-U5HSOKPQ.js";
+import "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Workers/createEllipsoidGeometry.js
+function createEllipsoidGeometry(ellipsoidGeometry, offset) {
+  if (defined_default(offset)) {
+    ellipsoidGeometry = EllipsoidGeometry_default.unpack(ellipsoidGeometry, offset);
+  }
+  return EllipsoidGeometry_default.createGeometry(ellipsoidGeometry);
+}
+var createEllipsoidGeometry_default = createEllipsoidGeometry;
+export {
+  createEllipsoidGeometry_default as default
+};

public/assets/cesium/Workers/createEllipsoidOutlineGeometry.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 {
+  EllipsoidOutlineGeometry_default
+} from "./chunk-OPP2SKMA.js";
+import "./chunk-GBT7MJ6X.js";
+import "./chunk-C4WPMOKT.js";
+import "./chunk-X7IQYYHF.js";
+import "./chunk-JXVLNVXC.js";
+import "./chunk-KHZNBFOH.js";
+import "./chunk-6SQMLVGV.js";
+import "./chunk-XIUSRWL6.js";
+import "./chunk-FFLMY4TE.js";
+import "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.js";
+import "./chunk-U5HSOKPQ.js";
+import "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Workers/createEllipsoidOutlineGeometry.js
+function createEllipsoidOutlineGeometry(ellipsoidGeometry, offset) {
+  if (defined_default(ellipsoidGeometry.buffer, offset)) {
+    ellipsoidGeometry = EllipsoidOutlineGeometry_default.unpack(
+      ellipsoidGeometry,
+      offset
+    );
+  }
+  return EllipsoidOutlineGeometry_default.createGeometry(ellipsoidGeometry);
+}
+var createEllipsoidOutlineGeometry_default = createEllipsoidOutlineGeometry;
+export {
+  createEllipsoidOutlineGeometry_default as default
+};

public/assets/cesium/Workers/createFrustumGeometry.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 {
+  FrustumGeometry_default
+} from "./chunk-7YIOHQWH.js";
+import "./chunk-JBSKHTNX.js";
+import "./chunk-EDLRS3AW.js";
+import "./chunk-X7IQYYHF.js";
+import "./chunk-JXVLNVXC.js";
+import "./chunk-KHZNBFOH.js";
+import "./chunk-6SQMLVGV.js";
+import "./chunk-XIUSRWL6.js";
+import "./chunk-FFLMY4TE.js";
+import "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.js";
+import "./chunk-U5HSOKPQ.js";
+import "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Workers/createFrustumGeometry.js
+function createFrustumGeometry(frustumGeometry, offset) {
+  if (defined_default(offset)) {
+    frustumGeometry = FrustumGeometry_default.unpack(frustumGeometry, offset);
+  }
+  return FrustumGeometry_default.createGeometry(frustumGeometry);
+}
+var createFrustumGeometry_default = createFrustumGeometry;
+export {
+  createFrustumGeometry_default as default
+};

public/assets/cesium/Workers/createFrustumOutlineGeometry.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 {
+  FrustumGeometry_default,
+  OrthographicFrustum_default,
+  PerspectiveFrustum_default
+} from "./chunk-7YIOHQWH.js";
+import "./chunk-JBSKHTNX.js";
+import "./chunk-EDLRS3AW.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 {
+  Quaternion_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian3_default
+} from "./chunk-FFLMY4TE.js";
+import "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.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/FrustumOutlineGeometry.js
+var PERSPECTIVE = 0;
+var ORTHOGRAPHIC = 1;
+function FrustumOutlineGeometry(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 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._workerName = "createFrustumOutlineGeometry";
+  this.packedLength = 2 + frustumPackedLength + Cartesian3_default.packedLength + Quaternion_default.packedLength;
+}
+FrustumOutlineGeometry.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;
+  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();
+FrustumOutlineGeometry.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 drawNearPlane = array[startingIndex] === 1;
+  if (!defined_default(result)) {
+    return new FrustumOutlineGeometry({
+      frustum,
+      origin,
+      orientation,
+      _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._drawNearPlane = drawNearPlane;
+  return result;
+};
+FrustumOutlineGeometry.createGeometry = function(frustumGeometry) {
+  const frustumType = frustumGeometry._frustumType;
+  const frustum = frustumGeometry._frustum;
+  const origin = frustumGeometry._origin;
+  const orientation = frustumGeometry._orientation;
+  const drawNearPlane = frustumGeometry._drawNearPlane;
+  const positions = new Float64Array(3 * 4 * 2);
+  FrustumGeometry_default._computeNearFarPlanes(
+    origin,
+    orientation,
+    frustumType,
+    frustum,
+    positions
+  );
+  const attributes = new GeometryAttributes_default({
+    position: new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.DOUBLE,
+      componentsPerAttribute: 3,
+      values: positions
+    })
+  });
+  let offset;
+  let index;
+  const numberOfPlanes = drawNearPlane ? 2 : 1;
+  const indices = new Uint16Array(8 * (numberOfPlanes + 1));
+  let i = drawNearPlane ? 0 : 1;
+  for (; i < 2; ++i) {
+    offset = drawNearPlane ? i * 8 : 0;
+    index = i * 4;
+    indices[offset] = index;
+    indices[offset + 1] = index + 1;
+    indices[offset + 2] = index + 1;
+    indices[offset + 3] = index + 2;
+    indices[offset + 4] = index + 2;
+    indices[offset + 5] = index + 3;
+    indices[offset + 6] = index + 3;
+    indices[offset + 7] = index;
+  }
+  for (i = 0; i < 2; ++i) {
+    offset = (numberOfPlanes + i) * 8;
+    index = i * 4;
+    indices[offset] = index;
+    indices[offset + 1] = index + 4;
+    indices[offset + 2] = index + 1;
+    indices[offset + 3] = index + 5;
+    indices[offset + 4] = index + 2;
+    indices[offset + 5] = index + 6;
+    indices[offset + 6] = index + 3;
+    indices[offset + 7] = index + 7;
+  }
+  return new Geometry_default({
+    attributes,
+    indices,
+    primitiveType: PrimitiveType_default.LINES,
+    boundingSphere: BoundingSphere_default.fromVertices(positions)
+  });
+};
+var FrustumOutlineGeometry_default = FrustumOutlineGeometry;
+
+// packages/engine/Source/Workers/createFrustumOutlineGeometry.js
+function createFrustumOutlineGeometry(frustumGeometry, offset) {
+  if (defined_default(offset)) {
+    frustumGeometry = FrustumOutlineGeometry_default.unpack(frustumGeometry, offset);
+  }
+  return FrustumOutlineGeometry_default.createGeometry(frustumGeometry);
+}
+var createFrustumOutlineGeometry_default = createFrustumOutlineGeometry;
+export {
+  createFrustumOutlineGeometry_default as default
+};

public/assets/cesium/Workers/createGeometry.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 {
+  PrimitivePipeline_default
+} from "./chunk-IBRIWOCM.js";
+import {
+  createTaskProcessorWorker_default
+} from "./chunk-Z2QP3CXW.js";
+import "./chunk-RJM36CNY.js";
+import "./chunk-7ZZ5LMZY.js";
+import "./chunk-LJ2JQHJT.js";
+import "./chunk-NGZJIN5Z.js";
+import "./chunk-QQOZO7KO.js";
+import "./chunk-EDLRS3AW.js";
+import "./chunk-C4WPMOKT.js";
+import "./chunk-X7IQYYHF.js";
+import "./chunk-JXVLNVXC.js";
+import "./chunk-KHZNBFOH.js";
+import "./chunk-6SQMLVGV.js";
+import "./chunk-XIUSRWL6.js";
+import "./chunk-FFLMY4TE.js";
+import "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.js";
+import {
+  defaultValue_default
+} from "./chunk-U5HSOKPQ.js";
+import {
+  DeveloperError_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  __glob,
+  __require,
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// import("./**/*.js") in packages/engine/Source/Workers/createGeometry.js
+var globImport_js = __glob({
+  "./combineGeometry.js": () => import("./combineGeometry.js"),
+  "./createBoxGeometry.js": () => import("./createBoxGeometry.js"),
+  "./createBoxOutlineGeometry.js": () => import("./createBoxOutlineGeometry.js"),
+  "./createCircleGeometry.js": () => import("./createCircleGeometry.js"),
+  "./createCircleOutlineGeometry.js": () => import("./createCircleOutlineGeometry.js"),
+  "./createCoplanarPolygonGeometry.js": () => import("./createCoplanarPolygonGeometry.js"),
+  "./createCoplanarPolygonOutlineGeometry.js": () => import("./createCoplanarPolygonOutlineGeometry.js"),
+  "./createCorridorGeometry.js": () => import("./createCorridorGeometry.js"),
+  "./createCorridorOutlineGeometry.js": () => import("./createCorridorOutlineGeometry.js"),
+  "./createCylinderGeometry.js": () => import("./createCylinderGeometry.js"),
+  "./createCylinderOutlineGeometry.js": () => import("./createCylinderOutlineGeometry.js"),
+  "./createEllipseGeometry.js": () => import("./createEllipseGeometry.js"),
+  "./createEllipseOutlineGeometry.js": () => import("./createEllipseOutlineGeometry.js"),
+  "./createEllipsoidGeometry.js": () => import("./createEllipsoidGeometry.js"),
+  "./createEllipsoidOutlineGeometry.js": () => import("./createEllipsoidOutlineGeometry.js"),
+  "./createFrustumGeometry.js": () => import("./createFrustumGeometry.js"),
+  "./createFrustumOutlineGeometry.js": () => import("./createFrustumOutlineGeometry.js"),
+  "./createGeometry.js": () => import("./createGeometry.js"),
+  "./createGroundPolylineGeometry.js": () => import("./createGroundPolylineGeometry.js"),
+  "./createPlaneGeometry.js": () => import("./createPlaneGeometry.js"),
+  "./createPlaneOutlineGeometry.js": () => import("./createPlaneOutlineGeometry.js"),
+  "./createPolygonGeometry.js": () => import("./createPolygonGeometry.js"),
+  "./createPolygonOutlineGeometry.js": () => import("./createPolygonOutlineGeometry.js"),
+  "./createPolylineGeometry.js": () => import("./createPolylineGeometry.js"),
+  "./createPolylineVolumeGeometry.js": () => import("./createPolylineVolumeGeometry.js"),
+  "./createPolylineVolumeOutlineGeometry.js": () => import("./createPolylineVolumeOutlineGeometry.js"),
+  "./createRectangleGeometry.js": () => import("./createRectangleGeometry.js"),
+  "./createRectangleOutlineGeometry.js": () => import("./createRectangleOutlineGeometry.js"),
+  "./createSimplePolylineGeometry.js": () => import("./createSimplePolylineGeometry.js"),
+  "./createSphereGeometry.js": () => import("./createSphereGeometry.js"),
+  "./createSphereOutlineGeometry.js": () => import("./createSphereOutlineGeometry.js"),
+  "./createTaskProcessorWorker.js": () => import("./createTaskProcessorWorker.js"),
+  "./createVectorTileClampedPolylines.js": () => import("./createVectorTileClampedPolylines.js"),
+  "./createVectorTileGeometries.js": () => import("./createVectorTileGeometries.js"),
+  "./createVectorTilePoints.js": () => import("./createVectorTilePoints.js"),
+  "./createVectorTilePolygons.js": () => import("./createVectorTilePolygons.js"),
+  "./createVectorTilePolylines.js": () => import("./createVectorTilePolylines.js"),
+  "./createVerticesFromGoogleEarthEnterpriseBuffer.js": () => import("./createVerticesFromGoogleEarthEnterpriseBuffer.js"),
+  "./createVerticesFromHeightmap.js": () => import("./createVerticesFromHeightmap.js"),
+  "./createVerticesFromQuantizedTerrainMesh.js": () => import("./createVerticesFromQuantizedTerrainMesh.js"),
+  "./createWallGeometry.js": () => import("./createWallGeometry.js"),
+  "./createWallOutlineGeometry.js": () => import("./createWallOutlineGeometry.js"),
+  "./decodeDraco.js": () => import("./decodeDraco.js"),
+  "./decodeGoogleEarthEnterprisePacket.js": () => import("./decodeGoogleEarthEnterprisePacket.js"),
+  "./decodeI3S.js": () => import("./decodeI3S.js"),
+  "./transcodeKTX2.js": () => import("./transcodeKTX2.js"),
+  "./transferTypedArrayTest.js": () => import("./transferTypedArrayTest.js"),
+  "./upsampleQuantizedTerrainMesh.js": () => import("./upsampleQuantizedTerrainMesh.js")
+});
+
+// packages/engine/Source/Workers/createGeometry.js
+var moduleCache = {};
+async function getModule(moduleName, modulePath) {
+  let module = defaultValue_default(moduleCache[modulePath], moduleCache[moduleName]);
+  if (defined_default(module)) {
+    return module;
+  }
+  if (defined_default(modulePath)) {
+    if (typeof exports === "object") {
+      module = __require(modulePath);
+    } else {
+      const result = await import(modulePath);
+      module = result.default;
+    }
+    moduleCache[modulePath] = module;
+    return module;
+  }
+  if (typeof exports === "object") {
+    module = __require(`Workers/${moduleName}`);
+  } else {
+    const result = defined_default(modulePath) ? await import(modulePath) : await globImport_js(`./${moduleName}.js`);
+    module = result.default;
+  }
+  moduleCache[moduleName] = module;
+  return module;
+}
+async function createGeometry(parameters, transferableObjects) {
+  const subTasks = parameters.subTasks;
+  const length = subTasks.length;
+  const resultsOrPromises = new Array(length);
+  for (let i = 0; i < length; i++) {
+    const task = subTasks[i];
+    const geometry = task.geometry;
+    const moduleName = task.moduleName;
+    const modulePath = task.modulePath;
+    if (defined_default(moduleName) && defined_default(modulePath)) {
+      throw new DeveloperError_default("Must only set moduleName or modulePath");
+    }
+    if (defined_default(moduleName) || defined_default(modulePath)) {
+      resultsOrPromises[i] = getModule(
+        moduleName,
+        modulePath
+      ).then((createFunction) => createFunction(geometry, task.offset));
+    } else {
+      resultsOrPromises[i] = geometry;
+    }
+  }
+  return Promise.all(resultsOrPromises).then(function(results) {
+    return PrimitivePipeline_default.packCreateGeometryResults(
+      results,
+      transferableObjects
+    );
+  });
+}
+var createGeometry_default = createTaskProcessorWorker_default(createGeometry);
+export {
+  createGeometry_default as default
+};

public/assets/cesium/Workers/createGroundPolylineGeometry.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 {
+  WebMercatorProjection_default
+} from "./chunk-RJM36CNY.js";
+import {
+  ArcType_default
+} from "./chunk-XWOUPGUF.js";
+import {
+  EncodedCartesian3_default
+} from "./chunk-NGZJIN5Z.js";
+import {
+  EllipsoidGeodesic_default
+} from "./chunk-C3EQ27WF.js";
+import {
+  arrayRemoveDuplicates_default
+} from "./chunk-57H6I3SV.js";
+import {
+  EllipsoidRhumbLine_default
+} from "./chunk-JSQJDZI4.js";
+import {
+  IntersectionTests_default
+} from "./chunk-QQOZO7KO.js";
+import {
+  Plane_default
+} from "./chunk-EDLRS3AW.js";
+import {
+  GeometryAttribute_default,
+  Geometry_default
+} from "./chunk-JXVLNVXC.js";
+import {
+  BoundingSphere_default,
+  GeographicProjection_default
+} from "./chunk-KHZNBFOH.js";
+import {
+  Quaternion_default,
+  Rectangle_default,
+  Resource_default,
+  buildModuleUrl_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian2_default,
+  Cartesian3_default,
+  Cartographic_default,
+  Ellipsoid_default,
+  Matrix3_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.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/GeographicTilingScheme.js
+function GeographicTilingScheme(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  this._ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.default);
+  this._rectangle = defaultValue_default(options.rectangle, Rectangle_default.MAX_VALUE);
+  this._projection = new GeographicProjection_default(this._ellipsoid);
+  this._numberOfLevelZeroTilesX = defaultValue_default(
+    options.numberOfLevelZeroTilesX,
+    2
+  );
+  this._numberOfLevelZeroTilesY = defaultValue_default(
+    options.numberOfLevelZeroTilesY,
+    1
+  );
+}
+Object.defineProperties(GeographicTilingScheme.prototype, {
+  /**
+   * Gets the ellipsoid that is tiled by this tiling scheme.
+   * @memberof GeographicTilingScheme.prototype
+   * @type {Ellipsoid}
+   */
+  ellipsoid: {
+    get: function() {
+      return this._ellipsoid;
+    }
+  },
+  /**
+   * Gets the rectangle, in radians, covered by this tiling scheme.
+   * @memberof GeographicTilingScheme.prototype
+   * @type {Rectangle}
+   */
+  rectangle: {
+    get: function() {
+      return this._rectangle;
+    }
+  },
+  /**
+   * Gets the map projection used by this tiling scheme.
+   * @memberof GeographicTilingScheme.prototype
+   * @type {MapProjection}
+   */
+  projection: {
+    get: function() {
+      return this._projection;
+    }
+  }
+});
+GeographicTilingScheme.prototype.getNumberOfXTilesAtLevel = function(level) {
+  return this._numberOfLevelZeroTilesX << level;
+};
+GeographicTilingScheme.prototype.getNumberOfYTilesAtLevel = function(level) {
+  return this._numberOfLevelZeroTilesY << level;
+};
+GeographicTilingScheme.prototype.rectangleToNativeRectangle = function(rectangle, result) {
+  Check_default.defined("rectangle", rectangle);
+  const west = Math_default.toDegrees(rectangle.west);
+  const south = Math_default.toDegrees(rectangle.south);
+  const east = Math_default.toDegrees(rectangle.east);
+  const north = Math_default.toDegrees(rectangle.north);
+  if (!defined_default(result)) {
+    return new Rectangle_default(west, south, east, north);
+  }
+  result.west = west;
+  result.south = south;
+  result.east = east;
+  result.north = north;
+  return result;
+};
+GeographicTilingScheme.prototype.tileXYToNativeRectangle = function(x, y, level, result) {
+  const rectangleRadians = this.tileXYToRectangle(x, y, level, result);
+  rectangleRadians.west = Math_default.toDegrees(rectangleRadians.west);
+  rectangleRadians.south = Math_default.toDegrees(rectangleRadians.south);
+  rectangleRadians.east = Math_default.toDegrees(rectangleRadians.east);
+  rectangleRadians.north = Math_default.toDegrees(rectangleRadians.north);
+  return rectangleRadians;
+};
+GeographicTilingScheme.prototype.tileXYToRectangle = function(x, y, level, result) {
+  const rectangle = this._rectangle;
+  const xTiles = this.getNumberOfXTilesAtLevel(level);
+  const yTiles = this.getNumberOfYTilesAtLevel(level);
+  const xTileWidth = rectangle.width / xTiles;
+  const west = x * xTileWidth + rectangle.west;
+  const east = (x + 1) * xTileWidth + rectangle.west;
+  const yTileHeight = rectangle.height / yTiles;
+  const north = rectangle.north - y * yTileHeight;
+  const south = rectangle.north - (y + 1) * yTileHeight;
+  if (!defined_default(result)) {
+    result = new Rectangle_default(west, south, east, north);
+  }
+  result.west = west;
+  result.south = south;
+  result.east = east;
+  result.north = north;
+  return result;
+};
+GeographicTilingScheme.prototype.positionToTileXY = function(position, level, result) {
+  const rectangle = this._rectangle;
+  if (!Rectangle_default.contains(rectangle, position)) {
+    return void 0;
+  }
+  const xTiles = this.getNumberOfXTilesAtLevel(level);
+  const yTiles = this.getNumberOfYTilesAtLevel(level);
+  const xTileWidth = rectangle.width / xTiles;
+  const yTileHeight = rectangle.height / yTiles;
+  let longitude = position.longitude;
+  if (rectangle.east < rectangle.west) {
+    longitude += Math_default.TWO_PI;
+  }
+  let xTileCoordinate = (longitude - rectangle.west) / xTileWidth | 0;
+  if (xTileCoordinate >= xTiles) {
+    xTileCoordinate = xTiles - 1;
+  }
+  let yTileCoordinate = (rectangle.north - position.latitude) / yTileHeight | 0;
+  if (yTileCoordinate >= yTiles) {
+    yTileCoordinate = yTiles - 1;
+  }
+  if (!defined_default(result)) {
+    return new Cartesian2_default(xTileCoordinate, yTileCoordinate);
+  }
+  result.x = xTileCoordinate;
+  result.y = yTileCoordinate;
+  return result;
+};
+var GeographicTilingScheme_default = GeographicTilingScheme;
+
+// packages/engine/Source/Core/ApproximateTerrainHeights.js
+var scratchDiagonalCartesianNE = new Cartesian3_default();
+var scratchDiagonalCartesianSW = new Cartesian3_default();
+var scratchDiagonalCartographic = new Cartographic_default();
+var scratchCenterCartesian = new Cartesian3_default();
+var scratchSurfaceCartesian = new Cartesian3_default();
+var scratchBoundingSphere = new BoundingSphere_default();
+var tilingScheme = new GeographicTilingScheme_default();
+var scratchCorners = [
+  new Cartographic_default(),
+  new Cartographic_default(),
+  new Cartographic_default(),
+  new Cartographic_default()
+];
+var scratchTileXY = new Cartesian2_default();
+var ApproximateTerrainHeights = {};
+ApproximateTerrainHeights.initialize = function() {
+  let initPromise = ApproximateTerrainHeights._initPromise;
+  if (defined_default(initPromise)) {
+    return initPromise;
+  }
+  initPromise = Resource_default.fetchJson(
+    buildModuleUrl_default("Assets/approximateTerrainHeights.json")
+  ).then(function(json) {
+    ApproximateTerrainHeights._terrainHeights = json;
+  });
+  ApproximateTerrainHeights._initPromise = initPromise;
+  return initPromise;
+};
+ApproximateTerrainHeights.getMinimumMaximumHeights = function(rectangle, ellipsoid) {
+  Check_default.defined("rectangle", rectangle);
+  if (!defined_default(ApproximateTerrainHeights._terrainHeights)) {
+    throw new DeveloperError_default(
+      "You must call ApproximateTerrainHeights.initialize and wait for the promise to resolve before using this function"
+    );
+  }
+  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.default);
+  const xyLevel = getTileXYLevel(rectangle);
+  let minTerrainHeight = ApproximateTerrainHeights._defaultMinTerrainHeight;
+  let maxTerrainHeight = ApproximateTerrainHeights._defaultMaxTerrainHeight;
+  if (defined_default(xyLevel)) {
+    const key = `${xyLevel.level}-${xyLevel.x}-${xyLevel.y}`;
+    const heights = ApproximateTerrainHeights._terrainHeights[key];
+    if (defined_default(heights)) {
+      minTerrainHeight = heights[0];
+      maxTerrainHeight = heights[1];
+    }
+    ellipsoid.cartographicToCartesian(
+      Rectangle_default.northeast(rectangle, scratchDiagonalCartographic),
+      scratchDiagonalCartesianNE
+    );
+    ellipsoid.cartographicToCartesian(
+      Rectangle_default.southwest(rectangle, scratchDiagonalCartographic),
+      scratchDiagonalCartesianSW
+    );
+    Cartesian3_default.midpoint(
+      scratchDiagonalCartesianSW,
+      scratchDiagonalCartesianNE,
+      scratchCenterCartesian
+    );
+    const surfacePosition = ellipsoid.scaleToGeodeticSurface(
+      scratchCenterCartesian,
+      scratchSurfaceCartesian
+    );
+    if (defined_default(surfacePosition)) {
+      const distance = Cartesian3_default.distance(
+        scratchCenterCartesian,
+        surfacePosition
+      );
+      minTerrainHeight = Math.min(minTerrainHeight, -distance);
+    } else {
+      minTerrainHeight = ApproximateTerrainHeights._defaultMinTerrainHeight;
+    }
+  }
+  minTerrainHeight = Math.max(
+    ApproximateTerrainHeights._defaultMinTerrainHeight,
+    minTerrainHeight
+  );
+  return {
+    minimumTerrainHeight: minTerrainHeight,
+    maximumTerrainHeight: maxTerrainHeight
+  };
+};
+ApproximateTerrainHeights.getBoundingSphere = function(rectangle, ellipsoid) {
+  Check_default.defined("rectangle", rectangle);
+  if (!defined_default(ApproximateTerrainHeights._terrainHeights)) {
+    throw new DeveloperError_default(
+      "You must call ApproximateTerrainHeights.initialize and wait for the promise to resolve before using this function"
+    );
+  }
+  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.default);
+  const xyLevel = getTileXYLevel(rectangle);
+  let maxTerrainHeight = ApproximateTerrainHeights._defaultMaxTerrainHeight;
+  if (defined_default(xyLevel)) {
+    const key = `${xyLevel.level}-${xyLevel.x}-${xyLevel.y}`;
+    const heights = ApproximateTerrainHeights._terrainHeights[key];
+    if (defined_default(heights)) {
+      maxTerrainHeight = heights[1];
+    }
+  }
+  const result = BoundingSphere_default.fromRectangle3D(rectangle, ellipsoid, 0);
+  BoundingSphere_default.fromRectangle3D(
+    rectangle,
+    ellipsoid,
+    maxTerrainHeight,
+    scratchBoundingSphere
+  );
+  return BoundingSphere_default.union(result, scratchBoundingSphere, result);
+};
+function getTileXYLevel(rectangle) {
+  Cartographic_default.fromRadians(
+    rectangle.east,
+    rectangle.north,
+    0,
+    scratchCorners[0]
+  );
+  Cartographic_default.fromRadians(
+    rectangle.west,
+    rectangle.north,
+    0,
+    scratchCorners[1]
+  );
+  Cartographic_default.fromRadians(
+    rectangle.east,
+    rectangle.south,
+    0,
+    scratchCorners[2]
+  );
+  Cartographic_default.fromRadians(
+    rectangle.west,
+    rectangle.south,
+    0,
+    scratchCorners[3]
+  );
+  let lastLevelX = 0, lastLevelY = 0;
+  let currentX = 0, currentY = 0;
+  const maxLevel = ApproximateTerrainHeights._terrainHeightsMaxLevel;
+  let i;
+  for (i = 0; i <= maxLevel; ++i) {
+    let failed = false;
+    for (let j = 0; j < 4; ++j) {
+      const corner = scratchCorners[j];
+      tilingScheme.positionToTileXY(corner, i, scratchTileXY);
+      if (j === 0) {
+        currentX = scratchTileXY.x;
+        currentY = scratchTileXY.y;
+      } else if (currentX !== scratchTileXY.x || currentY !== scratchTileXY.y) {
+        failed = true;
+        break;
+      }
+    }
+    if (failed) {
+      break;
+    }
+    lastLevelX = currentX;
+    lastLevelY = currentY;
+  }
+  if (i === 0) {
+    return void 0;
+  }
+  return {
+    x: lastLevelX,
+    y: lastLevelY,
+    level: i > maxLevel ? maxLevel : i - 1
+  };
+}
+ApproximateTerrainHeights._terrainHeightsMaxLevel = 6;
+ApproximateTerrainHeights._defaultMaxTerrainHeight = 9e3;
+ApproximateTerrainHeights._defaultMinTerrainHeight = -1e5;
+ApproximateTerrainHeights._terrainHeights = void 0;
+ApproximateTerrainHeights._initPromise = void 0;
+Object.defineProperties(ApproximateTerrainHeights, {
+  /**
+   * Determines if the terrain heights are initialized and ready to use. To initialize the terrain heights,
+   * call {@link ApproximateTerrainHeights#initialize} and wait for the returned promise to resolve.
+   * @type {boolean}
+   * @readonly
+   * @memberof ApproximateTerrainHeights
+   */
+  initialized: {
+    get: function() {
+      return defined_default(ApproximateTerrainHeights._terrainHeights);
+    }
+  }
+});
+var ApproximateTerrainHeights_default = ApproximateTerrainHeights;
+
+// packages/engine/Source/Core/GroundPolylineGeometry.js
+var PROJECTIONS = [GeographicProjection_default, WebMercatorProjection_default];
+var PROJECTION_COUNT = PROJECTIONS.length;
+var MITER_BREAK_SMALL = Math.cos(Math_default.toRadians(30));
+var MITER_BREAK_LARGE = Math.cos(Math_default.toRadians(150));
+var WALL_INITIAL_MIN_HEIGHT = 0;
+var WALL_INITIAL_MAX_HEIGHT = 1e3;
+function GroundPolylineGeometry(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const positions = options.positions;
+  if (!defined_default(positions) || positions.length < 2) {
+    throw new DeveloperError_default("At least two positions are required.");
+  }
+  if (defined_default(options.arcType) && options.arcType !== ArcType_default.GEODESIC && options.arcType !== ArcType_default.RHUMB) {
+    throw new DeveloperError_default(
+      "Valid options for arcType are ArcType.GEODESIC and ArcType.RHUMB."
+    );
+  }
+  this.width = defaultValue_default(options.width, 1);
+  this._positions = positions;
+  this.granularity = defaultValue_default(options.granularity, 9999);
+  this.loop = defaultValue_default(options.loop, false);
+  this.arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
+  this._ellipsoid = Ellipsoid_default.default;
+  this._projectionIndex = 0;
+  this._workerName = "createGroundPolylineGeometry";
+  this._scene3DOnly = false;
+}
+Object.defineProperties(GroundPolylineGeometry.prototype, {
+  /**
+   * The number of elements used to pack the object into an array.
+   * @memberof GroundPolylineGeometry.prototype
+   * @type {number}
+   * @readonly
+   * @private
+   */
+  packedLength: {
+    get: function() {
+      return 1 + this._positions.length * 3 + 1 + 1 + 1 + Ellipsoid_default.packedLength + 1 + 1;
+    }
+  }
+});
+GroundPolylineGeometry.setProjectionAndEllipsoid = function(groundPolylineGeometry, mapProjection) {
+  let projectionIndex = 0;
+  for (let i = 0; i < PROJECTION_COUNT; i++) {
+    if (mapProjection instanceof PROJECTIONS[i]) {
+      projectionIndex = i;
+      break;
+    }
+  }
+  groundPolylineGeometry._projectionIndex = projectionIndex;
+  groundPolylineGeometry._ellipsoid = mapProjection.ellipsoid;
+};
+var cart3Scratch1 = new Cartesian3_default();
+var cart3Scratch2 = new Cartesian3_default();
+var cart3Scratch3 = new Cartesian3_default();
+function computeRightNormal(start, end, maxHeight, ellipsoid, result) {
+  const startBottom = getPosition(ellipsoid, start, 0, cart3Scratch1);
+  const startTop = getPosition(ellipsoid, start, maxHeight, cart3Scratch2);
+  const endBottom = getPosition(ellipsoid, end, 0, cart3Scratch3);
+  const up = direction(startTop, startBottom, cart3Scratch2);
+  const forward = direction(endBottom, startBottom, cart3Scratch3);
+  Cartesian3_default.cross(forward, up, result);
+  return Cartesian3_default.normalize(result, result);
+}
+var interpolatedCartographicScratch = new Cartographic_default();
+var interpolatedBottomScratch = new Cartesian3_default();
+var interpolatedTopScratch = new Cartesian3_default();
+var interpolatedNormalScratch = new Cartesian3_default();
+function interpolateSegment(start, end, minHeight, maxHeight, granularity, arcType, ellipsoid, normalsArray, bottomPositionsArray, topPositionsArray, cartographicsArray) {
+  if (granularity === 0) {
+    return;
+  }
+  let ellipsoidLine;
+  if (arcType === ArcType_default.GEODESIC) {
+    ellipsoidLine = new EllipsoidGeodesic_default(start, end, ellipsoid);
+  } else if (arcType === ArcType_default.RHUMB) {
+    ellipsoidLine = new EllipsoidRhumbLine_default(start, end, ellipsoid);
+  }
+  const surfaceDistance = ellipsoidLine.surfaceDistance;
+  if (surfaceDistance < granularity) {
+    return;
+  }
+  const interpolatedNormal = computeRightNormal(
+    start,
+    end,
+    maxHeight,
+    ellipsoid,
+    interpolatedNormalScratch
+  );
+  const segments = Math.ceil(surfaceDistance / granularity);
+  const interpointDistance = surfaceDistance / segments;
+  let distanceFromStart = interpointDistance;
+  const pointsToAdd = segments - 1;
+  let packIndex = normalsArray.length;
+  for (let i = 0; i < pointsToAdd; i++) {
+    const interpolatedCartographic = ellipsoidLine.interpolateUsingSurfaceDistance(
+      distanceFromStart,
+      interpolatedCartographicScratch
+    );
+    const interpolatedBottom = getPosition(
+      ellipsoid,
+      interpolatedCartographic,
+      minHeight,
+      interpolatedBottomScratch
+    );
+    const interpolatedTop = getPosition(
+      ellipsoid,
+      interpolatedCartographic,
+      maxHeight,
+      interpolatedTopScratch
+    );
+    Cartesian3_default.pack(interpolatedNormal, normalsArray, packIndex);
+    Cartesian3_default.pack(interpolatedBottom, bottomPositionsArray, packIndex);
+    Cartesian3_default.pack(interpolatedTop, topPositionsArray, packIndex);
+    cartographicsArray.push(interpolatedCartographic.latitude);
+    cartographicsArray.push(interpolatedCartographic.longitude);
+    packIndex += 3;
+    distanceFromStart += interpointDistance;
+  }
+}
+var heightlessCartographicScratch = new Cartographic_default();
+function getPosition(ellipsoid, cartographic, height, result) {
+  Cartographic_default.clone(cartographic, heightlessCartographicScratch);
+  heightlessCartographicScratch.height = height;
+  return Cartographic_default.toCartesian(
+    heightlessCartographicScratch,
+    ellipsoid,
+    result
+  );
+}
+GroundPolylineGeometry.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  let index = defaultValue_default(startingIndex, 0);
+  const positions = value._positions;
+  const positionsLength = positions.length;
+  array[index++] = positionsLength;
+  for (let i = 0; i < positionsLength; ++i) {
+    const cartesian = positions[i];
+    Cartesian3_default.pack(cartesian, array, index);
+    index += 3;
+  }
+  array[index++] = value.granularity;
+  array[index++] = value.loop ? 1 : 0;
+  array[index++] = value.arcType;
+  Ellipsoid_default.pack(value._ellipsoid, array, index);
+  index += Ellipsoid_default.packedLength;
+  array[index++] = value._projectionIndex;
+  array[index++] = value._scene3DOnly ? 1 : 0;
+  return array;
+};
+GroundPolylineGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  let index = defaultValue_default(startingIndex, 0);
+  const positionsLength = array[index++];
+  const positions = new Array(positionsLength);
+  for (let i = 0; i < positionsLength; i++) {
+    positions[i] = Cartesian3_default.unpack(array, index);
+    index += 3;
+  }
+  const granularity = array[index++];
+  const loop = array[index++] === 1;
+  const arcType = array[index++];
+  const ellipsoid = Ellipsoid_default.unpack(array, index);
+  index += Ellipsoid_default.packedLength;
+  const projectionIndex = array[index++];
+  const scene3DOnly = array[index++] === 1;
+  if (!defined_default(result)) {
+    result = new GroundPolylineGeometry({
+      positions
+    });
+  }
+  result._positions = positions;
+  result.granularity = granularity;
+  result.loop = loop;
+  result.arcType = arcType;
+  result._ellipsoid = ellipsoid;
+  result._projectionIndex = projectionIndex;
+  result._scene3DOnly = scene3DOnly;
+  return result;
+};
+function direction(target, origin, result) {
+  Cartesian3_default.subtract(target, origin, result);
+  Cartesian3_default.normalize(result, result);
+  return result;
+}
+function tangentDirection(target, origin, up, result) {
+  result = direction(target, origin, result);
+  result = Cartesian3_default.cross(result, up, result);
+  result = Cartesian3_default.normalize(result, result);
+  result = Cartesian3_default.cross(up, result, result);
+  return result;
+}
+var toPreviousScratch = new Cartesian3_default();
+var toNextScratch = new Cartesian3_default();
+var forwardScratch = new Cartesian3_default();
+var vertexUpScratch = new Cartesian3_default();
+var cosine90 = 0;
+var cosine180 = -1;
+function computeVertexMiterNormal(previousBottom, vertexBottom, vertexTop, nextBottom, result) {
+  const up = direction(vertexTop, vertexBottom, vertexUpScratch);
+  const toPrevious = tangentDirection(
+    previousBottom,
+    vertexBottom,
+    up,
+    toPreviousScratch
+  );
+  const toNext = tangentDirection(nextBottom, vertexBottom, up, toNextScratch);
+  if (Math_default.equalsEpsilon(
+    Cartesian3_default.dot(toPrevious, toNext),
+    cosine180,
+    Math_default.EPSILON5
+  )) {
+    result = Cartesian3_default.cross(up, toPrevious, result);
+    result = Cartesian3_default.normalize(result, result);
+    return result;
+  }
+  result = Cartesian3_default.add(toNext, toPrevious, result);
+  result = Cartesian3_default.normalize(result, result);
+  const forward = Cartesian3_default.cross(up, result, forwardScratch);
+  if (Cartesian3_default.dot(toNext, forward) < cosine90) {
+    result = Cartesian3_default.negate(result, result);
+  }
+  return result;
+}
+var XZ_PLANE = Plane_default.fromPointNormal(Cartesian3_default.ZERO, Cartesian3_default.UNIT_Y);
+var previousBottomScratch = new Cartesian3_default();
+var vertexBottomScratch = new Cartesian3_default();
+var vertexTopScratch = new Cartesian3_default();
+var nextBottomScratch = new Cartesian3_default();
+var vertexNormalScratch = new Cartesian3_default();
+var intersectionScratch = new Cartesian3_default();
+var cartographicScratch0 = new Cartographic_default();
+var cartographicScratch1 = new Cartographic_default();
+var cartographicIntersectionScratch = new Cartographic_default();
+GroundPolylineGeometry.createGeometry = function(groundPolylineGeometry) {
+  const compute2dAttributes = !groundPolylineGeometry._scene3DOnly;
+  let loop = groundPolylineGeometry.loop;
+  const ellipsoid = groundPolylineGeometry._ellipsoid;
+  const granularity = groundPolylineGeometry.granularity;
+  const arcType = groundPolylineGeometry.arcType;
+  const projection = new PROJECTIONS[groundPolylineGeometry._projectionIndex](
+    ellipsoid
+  );
+  const minHeight = WALL_INITIAL_MIN_HEIGHT;
+  const maxHeight = WALL_INITIAL_MAX_HEIGHT;
+  let index;
+  let i;
+  const positions = groundPolylineGeometry._positions;
+  const positionsLength = positions.length;
+  if (positionsLength === 2) {
+    loop = false;
+  }
+  let p0;
+  let p1;
+  let c0;
+  let c1;
+  const rhumbLine = new EllipsoidRhumbLine_default(void 0, void 0, ellipsoid);
+  let intersection;
+  let intersectionCartographic;
+  let intersectionLongitude;
+  const splitPositions = [positions[0]];
+  for (i = 0; i < positionsLength - 1; i++) {
+    p0 = positions[i];
+    p1 = positions[i + 1];
+    intersection = IntersectionTests_default.lineSegmentPlane(
+      p0,
+      p1,
+      XZ_PLANE,
+      intersectionScratch
+    );
+    if (defined_default(intersection) && !Cartesian3_default.equalsEpsilon(intersection, p0, Math_default.EPSILON7) && !Cartesian3_default.equalsEpsilon(intersection, p1, Math_default.EPSILON7)) {
+      if (groundPolylineGeometry.arcType === ArcType_default.GEODESIC) {
+        splitPositions.push(Cartesian3_default.clone(intersection));
+      } else if (groundPolylineGeometry.arcType === ArcType_default.RHUMB) {
+        intersectionLongitude = ellipsoid.cartesianToCartographic(
+          intersection,
+          cartographicScratch0
+        ).longitude;
+        c0 = ellipsoid.cartesianToCartographic(p0, cartographicScratch0);
+        c1 = ellipsoid.cartesianToCartographic(p1, cartographicScratch1);
+        rhumbLine.setEndPoints(c0, c1);
+        intersectionCartographic = rhumbLine.findIntersectionWithLongitude(
+          intersectionLongitude,
+          cartographicIntersectionScratch
+        );
+        intersection = ellipsoid.cartographicToCartesian(
+          intersectionCartographic,
+          intersectionScratch
+        );
+        if (defined_default(intersection) && !Cartesian3_default.equalsEpsilon(intersection, p0, Math_default.EPSILON7) && !Cartesian3_default.equalsEpsilon(intersection, p1, Math_default.EPSILON7)) {
+          splitPositions.push(Cartesian3_default.clone(intersection));
+        }
+      }
+    }
+    splitPositions.push(p1);
+  }
+  if (loop) {
+    p0 = positions[positionsLength - 1];
+    p1 = positions[0];
+    intersection = IntersectionTests_default.lineSegmentPlane(
+      p0,
+      p1,
+      XZ_PLANE,
+      intersectionScratch
+    );
+    if (defined_default(intersection) && !Cartesian3_default.equalsEpsilon(intersection, p0, Math_default.EPSILON7) && !Cartesian3_default.equalsEpsilon(intersection, p1, Math_default.EPSILON7)) {
+      if (groundPolylineGeometry.arcType === ArcType_default.GEODESIC) {
+        splitPositions.push(Cartesian3_default.clone(intersection));
+      } else if (groundPolylineGeometry.arcType === ArcType_default.RHUMB) {
+        intersectionLongitude = ellipsoid.cartesianToCartographic(
+          intersection,
+          cartographicScratch0
+        ).longitude;
+        c0 = ellipsoid.cartesianToCartographic(p0, cartographicScratch0);
+        c1 = ellipsoid.cartesianToCartographic(p1, cartographicScratch1);
+        rhumbLine.setEndPoints(c0, c1);
+        intersectionCartographic = rhumbLine.findIntersectionWithLongitude(
+          intersectionLongitude,
+          cartographicIntersectionScratch
+        );
+        intersection = ellipsoid.cartographicToCartesian(
+          intersectionCartographic,
+          intersectionScratch
+        );
+        if (defined_default(intersection) && !Cartesian3_default.equalsEpsilon(intersection, p0, Math_default.EPSILON7) && !Cartesian3_default.equalsEpsilon(intersection, p1, Math_default.EPSILON7)) {
+          splitPositions.push(Cartesian3_default.clone(intersection));
+        }
+      }
+    }
+  }
+  let cartographicsLength = splitPositions.length;
+  let cartographics = new Array(cartographicsLength);
+  for (i = 0; i < cartographicsLength; i++) {
+    const cartographic = Cartographic_default.fromCartesian(
+      splitPositions[i],
+      ellipsoid
+    );
+    cartographic.height = 0;
+    cartographics[i] = cartographic;
+  }
+  cartographics = arrayRemoveDuplicates_default(
+    cartographics,
+    Cartographic_default.equalsEpsilon
+  );
+  cartographicsLength = cartographics.length;
+  if (cartographicsLength < 2) {
+    return void 0;
+  }
+  const cartographicsArray = [];
+  const normalsArray = [];
+  const bottomPositionsArray = [];
+  const topPositionsArray = [];
+  let previousBottom = previousBottomScratch;
+  let vertexBottom = vertexBottomScratch;
+  let vertexTop = vertexTopScratch;
+  let nextBottom = nextBottomScratch;
+  let vertexNormal = vertexNormalScratch;
+  const startCartographic = cartographics[0];
+  const nextCartographic = cartographics[1];
+  const prestartCartographic = cartographics[cartographicsLength - 1];
+  previousBottom = getPosition(
+    ellipsoid,
+    prestartCartographic,
+    minHeight,
+    previousBottom
+  );
+  nextBottom = getPosition(ellipsoid, nextCartographic, minHeight, nextBottom);
+  vertexBottom = getPosition(
+    ellipsoid,
+    startCartographic,
+    minHeight,
+    vertexBottom
+  );
+  vertexTop = getPosition(ellipsoid, startCartographic, maxHeight, vertexTop);
+  if (loop) {
+    vertexNormal = computeVertexMiterNormal(
+      previousBottom,
+      vertexBottom,
+      vertexTop,
+      nextBottom,
+      vertexNormal
+    );
+  } else {
+    vertexNormal = computeRightNormal(
+      startCartographic,
+      nextCartographic,
+      maxHeight,
+      ellipsoid,
+      vertexNormal
+    );
+  }
+  Cartesian3_default.pack(vertexNormal, normalsArray, 0);
+  Cartesian3_default.pack(vertexBottom, bottomPositionsArray, 0);
+  Cartesian3_default.pack(vertexTop, topPositionsArray, 0);
+  cartographicsArray.push(startCartographic.latitude);
+  cartographicsArray.push(startCartographic.longitude);
+  interpolateSegment(
+    startCartographic,
+    nextCartographic,
+    minHeight,
+    maxHeight,
+    granularity,
+    arcType,
+    ellipsoid,
+    normalsArray,
+    bottomPositionsArray,
+    topPositionsArray,
+    cartographicsArray
+  );
+  for (i = 1; i < cartographicsLength - 1; ++i) {
+    previousBottom = Cartesian3_default.clone(vertexBottom, previousBottom);
+    vertexBottom = Cartesian3_default.clone(nextBottom, vertexBottom);
+    const vertexCartographic = cartographics[i];
+    getPosition(ellipsoid, vertexCartographic, maxHeight, vertexTop);
+    getPosition(ellipsoid, cartographics[i + 1], minHeight, nextBottom);
+    computeVertexMiterNormal(
+      previousBottom,
+      vertexBottom,
+      vertexTop,
+      nextBottom,
+      vertexNormal
+    );
+    index = normalsArray.length;
+    Cartesian3_default.pack(vertexNormal, normalsArray, index);
+    Cartesian3_default.pack(vertexBottom, bottomPositionsArray, index);
+    Cartesian3_default.pack(vertexTop, topPositionsArray, index);
+    cartographicsArray.push(vertexCartographic.latitude);
+    cartographicsArray.push(vertexCartographic.longitude);
+    interpolateSegment(
+      cartographics[i],
+      cartographics[i + 1],
+      minHeight,
+      maxHeight,
+      granularity,
+      arcType,
+      ellipsoid,
+      normalsArray,
+      bottomPositionsArray,
+      topPositionsArray,
+      cartographicsArray
+    );
+  }
+  const endCartographic = cartographics[cartographicsLength - 1];
+  const preEndCartographic = cartographics[cartographicsLength - 2];
+  vertexBottom = getPosition(
+    ellipsoid,
+    endCartographic,
+    minHeight,
+    vertexBottom
+  );
+  vertexTop = getPosition(ellipsoid, endCartographic, maxHeight, vertexTop);
+  if (loop) {
+    const postEndCartographic = cartographics[0];
+    previousBottom = getPosition(
+      ellipsoid,
+      preEndCartographic,
+      minHeight,
+      previousBottom
+    );
+    nextBottom = getPosition(
+      ellipsoid,
+      postEndCartographic,
+      minHeight,
+      nextBottom
+    );
+    vertexNormal = computeVertexMiterNormal(
+      previousBottom,
+      vertexBottom,
+      vertexTop,
+      nextBottom,
+      vertexNormal
+    );
+  } else {
+    vertexNormal = computeRightNormal(
+      preEndCartographic,
+      endCartographic,
+      maxHeight,
+      ellipsoid,
+      vertexNormal
+    );
+  }
+  index = normalsArray.length;
+  Cartesian3_default.pack(vertexNormal, normalsArray, index);
+  Cartesian3_default.pack(vertexBottom, bottomPositionsArray, index);
+  Cartesian3_default.pack(vertexTop, topPositionsArray, index);
+  cartographicsArray.push(endCartographic.latitude);
+  cartographicsArray.push(endCartographic.longitude);
+  if (loop) {
+    interpolateSegment(
+      endCartographic,
+      startCartographic,
+      minHeight,
+      maxHeight,
+      granularity,
+      arcType,
+      ellipsoid,
+      normalsArray,
+      bottomPositionsArray,
+      topPositionsArray,
+      cartographicsArray
+    );
+    index = normalsArray.length;
+    for (i = 0; i < 3; ++i) {
+      normalsArray[index + i] = normalsArray[i];
+      bottomPositionsArray[index + i] = bottomPositionsArray[i];
+      topPositionsArray[index + i] = topPositionsArray[i];
+    }
+    cartographicsArray.push(startCartographic.latitude);
+    cartographicsArray.push(startCartographic.longitude);
+  }
+  return generateGeometryAttributes(
+    loop,
+    projection,
+    bottomPositionsArray,
+    topPositionsArray,
+    normalsArray,
+    cartographicsArray,
+    compute2dAttributes
+  );
+};
+var lineDirectionScratch = new Cartesian3_default();
+var matrix3Scratch = new Matrix3_default();
+var quaternionScratch = new Quaternion_default();
+function breakMiter(endGeometryNormal, startBottom, endBottom, endTop) {
+  const lineDirection = direction(endBottom, startBottom, lineDirectionScratch);
+  const dot = Cartesian3_default.dot(lineDirection, endGeometryNormal);
+  if (dot > MITER_BREAK_SMALL || dot < MITER_BREAK_LARGE) {
+    const vertexUp = direction(endTop, endBottom, vertexUpScratch);
+    const angle = dot < MITER_BREAK_LARGE ? Math_default.PI_OVER_TWO : -Math_default.PI_OVER_TWO;
+    const quaternion = Quaternion_default.fromAxisAngle(
+      vertexUp,
+      angle,
+      quaternionScratch
+    );
+    const rotationMatrix = Matrix3_default.fromQuaternion(quaternion, matrix3Scratch);
+    Matrix3_default.multiplyByVector(
+      rotationMatrix,
+      endGeometryNormal,
+      endGeometryNormal
+    );
+    return true;
+  }
+  return false;
+}
+var endPosCartographicScratch = new Cartographic_default();
+var normalStartpointScratch = new Cartesian3_default();
+var normalEndpointScratch = new Cartesian3_default();
+function projectNormal(projection, cartographic, normal, projectedPosition, result) {
+  const position = Cartographic_default.toCartesian(
+    cartographic,
+    projection._ellipsoid,
+    normalStartpointScratch
+  );
+  let normalEndpoint = Cartesian3_default.add(position, normal, normalEndpointScratch);
+  let flipNormal = false;
+  const ellipsoid = projection._ellipsoid;
+  let normalEndpointCartographic = ellipsoid.cartesianToCartographic(
+    normalEndpoint,
+    endPosCartographicScratch
+  );
+  if (Math.abs(cartographic.longitude - normalEndpointCartographic.longitude) > Math_default.PI_OVER_TWO) {
+    flipNormal = true;
+    normalEndpoint = Cartesian3_default.subtract(
+      position,
+      normal,
+      normalEndpointScratch
+    );
+    normalEndpointCartographic = ellipsoid.cartesianToCartographic(
+      normalEndpoint,
+      endPosCartographicScratch
+    );
+  }
+  normalEndpointCartographic.height = 0;
+  const normalEndpointProjected = projection.project(
+    normalEndpointCartographic,
+    result
+  );
+  result = Cartesian3_default.subtract(
+    normalEndpointProjected,
+    projectedPosition,
+    result
+  );
+  result.z = 0;
+  result = Cartesian3_default.normalize(result, result);
+  if (flipNormal) {
+    Cartesian3_default.negate(result, result);
+  }
+  return result;
+}
+var adjustHeightNormalScratch = new Cartesian3_default();
+var adjustHeightOffsetScratch = new Cartesian3_default();
+function adjustHeights(bottom, top, minHeight, maxHeight, adjustHeightBottom, adjustHeightTop) {
+  const adjustHeightNormal = Cartesian3_default.subtract(
+    top,
+    bottom,
+    adjustHeightNormalScratch
+  );
+  Cartesian3_default.normalize(adjustHeightNormal, adjustHeightNormal);
+  const distanceForBottom = minHeight - WALL_INITIAL_MIN_HEIGHT;
+  let adjustHeightOffset = Cartesian3_default.multiplyByScalar(
+    adjustHeightNormal,
+    distanceForBottom,
+    adjustHeightOffsetScratch
+  );
+  Cartesian3_default.add(bottom, adjustHeightOffset, adjustHeightBottom);
+  const distanceForTop = maxHeight - WALL_INITIAL_MAX_HEIGHT;
+  adjustHeightOffset = Cartesian3_default.multiplyByScalar(
+    adjustHeightNormal,
+    distanceForTop,
+    adjustHeightOffsetScratch
+  );
+  Cartesian3_default.add(top, adjustHeightOffset, adjustHeightTop);
+}
+var nudgeDirectionScratch = new Cartesian3_default();
+function nudgeXZ(start, end) {
+  const startToXZdistance = Plane_default.getPointDistance(XZ_PLANE, start);
+  const endToXZdistance = Plane_default.getPointDistance(XZ_PLANE, end);
+  let offset = nudgeDirectionScratch;
+  if (Math_default.equalsEpsilon(startToXZdistance, 0, Math_default.EPSILON2)) {
+    offset = direction(end, start, offset);
+    Cartesian3_default.multiplyByScalar(offset, Math_default.EPSILON2, offset);
+    Cartesian3_default.add(start, offset, start);
+  } else if (Math_default.equalsEpsilon(endToXZdistance, 0, Math_default.EPSILON2)) {
+    offset = direction(start, end, offset);
+    Cartesian3_default.multiplyByScalar(offset, Math_default.EPSILON2, offset);
+    Cartesian3_default.add(end, offset, end);
+  }
+}
+function nudgeCartographic(start, end) {
+  const absStartLon = Math.abs(start.longitude);
+  const absEndLon = Math.abs(end.longitude);
+  if (Math_default.equalsEpsilon(absStartLon, Math_default.PI, Math_default.EPSILON11)) {
+    const endSign = Math_default.sign(end.longitude);
+    start.longitude = endSign * (absStartLon - Math_default.EPSILON11);
+    return 1;
+  } else if (Math_default.equalsEpsilon(absEndLon, Math_default.PI, Math_default.EPSILON11)) {
+    const startSign = Math_default.sign(start.longitude);
+    end.longitude = startSign * (absEndLon - Math_default.EPSILON11);
+    return 2;
+  }
+  return 0;
+}
+var startCartographicScratch = new Cartographic_default();
+var endCartographicScratch = new Cartographic_default();
+var segmentStartTopScratch = new Cartesian3_default();
+var segmentEndTopScratch = new Cartesian3_default();
+var segmentStartBottomScratch = new Cartesian3_default();
+var segmentEndBottomScratch = new Cartesian3_default();
+var segmentStartNormalScratch = new Cartesian3_default();
+var segmentEndNormalScratch = new Cartesian3_default();
+var getHeightCartographics = [
+  startCartographicScratch,
+  endCartographicScratch
+];
+var getHeightRectangleScratch = new Rectangle_default();
+var adjustHeightStartTopScratch = new Cartesian3_default();
+var adjustHeightEndTopScratch = new Cartesian3_default();
+var adjustHeightStartBottomScratch = new Cartesian3_default();
+var adjustHeightEndBottomScratch = new Cartesian3_default();
+var segmentStart2DScratch = new Cartesian3_default();
+var segmentEnd2DScratch = new Cartesian3_default();
+var segmentStartNormal2DScratch = new Cartesian3_default();
+var segmentEndNormal2DScratch = new Cartesian3_default();
+var offsetScratch = new Cartesian3_default();
+var startUpScratch = new Cartesian3_default();
+var endUpScratch = new Cartesian3_default();
+var rightScratch = new Cartesian3_default();
+var startPlaneNormalScratch = new Cartesian3_default();
+var endPlaneNormalScratch = new Cartesian3_default();
+var encodeScratch = new EncodedCartesian3_default();
+var encodeScratch2D = new EncodedCartesian3_default();
+var forwardOffset2DScratch = new Cartesian3_default();
+var right2DScratch = new Cartesian3_default();
+var normalNudgeScratch = new Cartesian3_default();
+var scratchBoundingSpheres = [new BoundingSphere_default(), new BoundingSphere_default()];
+var REFERENCE_INDICES = [
+  0,
+  2,
+  1,
+  0,
+  3,
+  2,
+  // right
+  0,
+  7,
+  3,
+  0,
+  4,
+  7,
+  // start
+  0,
+  5,
+  4,
+  0,
+  1,
+  5,
+  // bottom
+  5,
+  7,
+  4,
+  5,
+  6,
+  7,
+  // left
+  5,
+  2,
+  6,
+  5,
+  1,
+  2,
+  // end
+  3,
+  6,
+  2,
+  3,
+  7,
+  6
+  // top
+];
+var REFERENCE_INDICES_LENGTH = REFERENCE_INDICES.length;
+function generateGeometryAttributes(loop, projection, bottomPositionsArray, topPositionsArray, normalsArray, cartographicsArray, compute2dAttributes) {
+  let i;
+  let index;
+  const ellipsoid = projection._ellipsoid;
+  const segmentCount = bottomPositionsArray.length / 3 - 1;
+  const vertexCount = segmentCount * 8;
+  const arraySizeVec4 = vertexCount * 4;
+  const indexCount = segmentCount * 36;
+  const indices = vertexCount > 65535 ? new Uint32Array(indexCount) : new Uint16Array(indexCount);
+  const positionsArray = new Float64Array(vertexCount * 3);
+  const startHiAndForwardOffsetX = new Float32Array(arraySizeVec4);
+  const startLoAndForwardOffsetY = new Float32Array(arraySizeVec4);
+  const startNormalAndForwardOffsetZ = new Float32Array(arraySizeVec4);
+  const endNormalAndTextureCoordinateNormalizationX = new Float32Array(
+    arraySizeVec4
+  );
+  const rightNormalAndTextureCoordinateNormalizationY = new Float32Array(
+    arraySizeVec4
+  );
+  let startHiLo2D;
+  let offsetAndRight2D;
+  let startEndNormals2D;
+  let texcoordNormalization2D;
+  if (compute2dAttributes) {
+    startHiLo2D = new Float32Array(arraySizeVec4);
+    offsetAndRight2D = new Float32Array(arraySizeVec4);
+    startEndNormals2D = new Float32Array(arraySizeVec4);
+    texcoordNormalization2D = new Float32Array(vertexCount * 2);
+  }
+  const cartographicsLength = cartographicsArray.length / 2;
+  let length2D = 0;
+  const startCartographic = startCartographicScratch;
+  startCartographic.height = 0;
+  const endCartographic = endCartographicScratch;
+  endCartographic.height = 0;
+  let segmentStartCartesian = segmentStartTopScratch;
+  let segmentEndCartesian = segmentEndTopScratch;
+  if (compute2dAttributes) {
+    index = 0;
+    for (i = 1; i < cartographicsLength; i++) {
+      startCartographic.latitude = cartographicsArray[index];
+      startCartographic.longitude = cartographicsArray[index + 1];
+      endCartographic.latitude = cartographicsArray[index + 2];
+      endCartographic.longitude = cartographicsArray[index + 3];
+      segmentStartCartesian = projection.project(
+        startCartographic,
+        segmentStartCartesian
+      );
+      segmentEndCartesian = projection.project(
+        endCartographic,
+        segmentEndCartesian
+      );
+      length2D += Cartesian3_default.distance(
+        segmentStartCartesian,
+        segmentEndCartesian
+      );
+      index += 2;
+    }
+  }
+  const positionsLength = topPositionsArray.length / 3;
+  segmentEndCartesian = Cartesian3_default.unpack(
+    topPositionsArray,
+    0,
+    segmentEndCartesian
+  );
+  let length3D = 0;
+  index = 3;
+  for (i = 1; i < positionsLength; i++) {
+    segmentStartCartesian = Cartesian3_default.clone(
+      segmentEndCartesian,
+      segmentStartCartesian
+    );
+    segmentEndCartesian = Cartesian3_default.unpack(
+      topPositionsArray,
+      index,
+      segmentEndCartesian
+    );
+    length3D += Cartesian3_default.distance(segmentStartCartesian, segmentEndCartesian);
+    index += 3;
+  }
+  let j;
+  index = 3;
+  let cartographicsIndex = 0;
+  let vec2sWriteIndex = 0;
+  let vec3sWriteIndex = 0;
+  let vec4sWriteIndex = 0;
+  let miterBroken = false;
+  let endBottom = Cartesian3_default.unpack(
+    bottomPositionsArray,
+    0,
+    segmentEndBottomScratch
+  );
+  let endTop = Cartesian3_default.unpack(topPositionsArray, 0, segmentEndTopScratch);
+  let endGeometryNormal = Cartesian3_default.unpack(
+    normalsArray,
+    0,
+    segmentEndNormalScratch
+  );
+  if (loop) {
+    const preEndBottom = Cartesian3_default.unpack(
+      bottomPositionsArray,
+      bottomPositionsArray.length - 6,
+      segmentStartBottomScratch
+    );
+    if (breakMiter(endGeometryNormal, preEndBottom, endBottom, endTop)) {
+      endGeometryNormal = Cartesian3_default.negate(
+        endGeometryNormal,
+        endGeometryNormal
+      );
+    }
+  }
+  let lengthSoFar3D = 0;
+  let lengthSoFar2D = 0;
+  let sumHeights = 0;
+  for (i = 0; i < segmentCount; i++) {
+    const startBottom = Cartesian3_default.clone(endBottom, segmentStartBottomScratch);
+    const startTop = Cartesian3_default.clone(endTop, segmentStartTopScratch);
+    let startGeometryNormal = Cartesian3_default.clone(
+      endGeometryNormal,
+      segmentStartNormalScratch
+    );
+    if (miterBroken) {
+      startGeometryNormal = Cartesian3_default.negate(
+        startGeometryNormal,
+        startGeometryNormal
+      );
+    }
+    endBottom = Cartesian3_default.unpack(
+      bottomPositionsArray,
+      index,
+      segmentEndBottomScratch
+    );
+    endTop = Cartesian3_default.unpack(topPositionsArray, index, segmentEndTopScratch);
+    endGeometryNormal = Cartesian3_default.unpack(
+      normalsArray,
+      index,
+      segmentEndNormalScratch
+    );
+    miterBroken = breakMiter(endGeometryNormal, startBottom, endBottom, endTop);
+    startCartographic.latitude = cartographicsArray[cartographicsIndex];
+    startCartographic.longitude = cartographicsArray[cartographicsIndex + 1];
+    endCartographic.latitude = cartographicsArray[cartographicsIndex + 2];
+    endCartographic.longitude = cartographicsArray[cartographicsIndex + 3];
+    let start2D;
+    let end2D;
+    let startGeometryNormal2D;
+    let endGeometryNormal2D;
+    if (compute2dAttributes) {
+      const nudgeResult = nudgeCartographic(startCartographic, endCartographic);
+      start2D = projection.project(startCartographic, segmentStart2DScratch);
+      end2D = projection.project(endCartographic, segmentEnd2DScratch);
+      const direction2D = direction(end2D, start2D, forwardOffset2DScratch);
+      direction2D.y = Math.abs(direction2D.y);
+      startGeometryNormal2D = segmentStartNormal2DScratch;
+      endGeometryNormal2D = segmentEndNormal2DScratch;
+      if (nudgeResult === 0 || Cartesian3_default.dot(direction2D, Cartesian3_default.UNIT_Y) > MITER_BREAK_SMALL) {
+        startGeometryNormal2D = projectNormal(
+          projection,
+          startCartographic,
+          startGeometryNormal,
+          start2D,
+          segmentStartNormal2DScratch
+        );
+        endGeometryNormal2D = projectNormal(
+          projection,
+          endCartographic,
+          endGeometryNormal,
+          end2D,
+          segmentEndNormal2DScratch
+        );
+      } else if (nudgeResult === 1) {
+        endGeometryNormal2D = projectNormal(
+          projection,
+          endCartographic,
+          endGeometryNormal,
+          end2D,
+          segmentEndNormal2DScratch
+        );
+        startGeometryNormal2D.x = 0;
+        startGeometryNormal2D.y = Math_default.sign(
+          startCartographic.longitude - Math.abs(endCartographic.longitude)
+        );
+        startGeometryNormal2D.z = 0;
+      } else {
+        startGeometryNormal2D = projectNormal(
+          projection,
+          startCartographic,
+          startGeometryNormal,
+          start2D,
+          segmentStartNormal2DScratch
+        );
+        endGeometryNormal2D.x = 0;
+        endGeometryNormal2D.y = Math_default.sign(
+          startCartographic.longitude - endCartographic.longitude
+        );
+        endGeometryNormal2D.z = 0;
+      }
+    }
+    const segmentLength3D = Cartesian3_default.distance(startTop, endTop);
+    const encodedStart = EncodedCartesian3_default.fromCartesian(
+      startBottom,
+      encodeScratch
+    );
+    const forwardOffset = Cartesian3_default.subtract(
+      endBottom,
+      startBottom,
+      offsetScratch
+    );
+    const forward = Cartesian3_default.normalize(forwardOffset, rightScratch);
+    let startUp = Cartesian3_default.subtract(startTop, startBottom, startUpScratch);
+    startUp = Cartesian3_default.normalize(startUp, startUp);
+    let rightNormal = Cartesian3_default.cross(forward, startUp, rightScratch);
+    rightNormal = Cartesian3_default.normalize(rightNormal, rightNormal);
+    let startPlaneNormal = Cartesian3_default.cross(
+      startUp,
+      startGeometryNormal,
+      startPlaneNormalScratch
+    );
+    startPlaneNormal = Cartesian3_default.normalize(startPlaneNormal, startPlaneNormal);
+    let endUp = Cartesian3_default.subtract(endTop, endBottom, endUpScratch);
+    endUp = Cartesian3_default.normalize(endUp, endUp);
+    let endPlaneNormal = Cartesian3_default.cross(
+      endGeometryNormal,
+      endUp,
+      endPlaneNormalScratch
+    );
+    endPlaneNormal = Cartesian3_default.normalize(endPlaneNormal, endPlaneNormal);
+    const texcoordNormalization3DX = segmentLength3D / length3D;
+    const texcoordNormalization3DY = lengthSoFar3D / length3D;
+    let segmentLength2D = 0;
+    let encodedStart2D;
+    let forwardOffset2D;
+    let right2D;
+    let texcoordNormalization2DX = 0;
+    let texcoordNormalization2DY = 0;
+    if (compute2dAttributes) {
+      segmentLength2D = Cartesian3_default.distance(start2D, end2D);
+      encodedStart2D = EncodedCartesian3_default.fromCartesian(
+        start2D,
+        encodeScratch2D
+      );
+      forwardOffset2D = Cartesian3_default.subtract(
+        end2D,
+        start2D,
+        forwardOffset2DScratch
+      );
+      right2D = Cartesian3_default.normalize(forwardOffset2D, right2DScratch);
+      const swap = right2D.x;
+      right2D.x = right2D.y;
+      right2D.y = -swap;
+      texcoordNormalization2DX = segmentLength2D / length2D;
+      texcoordNormalization2DY = lengthSoFar2D / length2D;
+    }
+    for (j = 0; j < 8; j++) {
+      const vec4Index = vec4sWriteIndex + j * 4;
+      const vec2Index = vec2sWriteIndex + j * 2;
+      const wIndex = vec4Index + 3;
+      const rightPlaneSide = j < 4 ? 1 : -1;
+      const topBottomSide = j === 2 || j === 3 || j === 6 || j === 7 ? 1 : -1;
+      Cartesian3_default.pack(encodedStart.high, startHiAndForwardOffsetX, vec4Index);
+      startHiAndForwardOffsetX[wIndex] = forwardOffset.x;
+      Cartesian3_default.pack(encodedStart.low, startLoAndForwardOffsetY, vec4Index);
+      startLoAndForwardOffsetY[wIndex] = forwardOffset.y;
+      Cartesian3_default.pack(
+        startPlaneNormal,
+        startNormalAndForwardOffsetZ,
+        vec4Index
+      );
+      startNormalAndForwardOffsetZ[wIndex] = forwardOffset.z;
+      Cartesian3_default.pack(
+        endPlaneNormal,
+        endNormalAndTextureCoordinateNormalizationX,
+        vec4Index
+      );
+      endNormalAndTextureCoordinateNormalizationX[wIndex] = texcoordNormalization3DX * rightPlaneSide;
+      Cartesian3_default.pack(
+        rightNormal,
+        rightNormalAndTextureCoordinateNormalizationY,
+        vec4Index
+      );
+      let texcoordNormalization = texcoordNormalization3DY * topBottomSide;
+      if (texcoordNormalization === 0 && topBottomSide < 0) {
+        texcoordNormalization = 9;
+      }
+      rightNormalAndTextureCoordinateNormalizationY[wIndex] = texcoordNormalization;
+      if (compute2dAttributes) {
+        startHiLo2D[vec4Index] = encodedStart2D.high.x;
+        startHiLo2D[vec4Index + 1] = encodedStart2D.high.y;
+        startHiLo2D[vec4Index + 2] = encodedStart2D.low.x;
+        startHiLo2D[vec4Index + 3] = encodedStart2D.low.y;
+        startEndNormals2D[vec4Index] = -startGeometryNormal2D.y;
+        startEndNormals2D[vec4Index + 1] = startGeometryNormal2D.x;
+        startEndNormals2D[vec4Index + 2] = endGeometryNormal2D.y;
+        startEndNormals2D[vec4Index + 3] = -endGeometryNormal2D.x;
+        offsetAndRight2D[vec4Index] = forwardOffset2D.x;
+        offsetAndRight2D[vec4Index + 1] = forwardOffset2D.y;
+        offsetAndRight2D[vec4Index + 2] = right2D.x;
+        offsetAndRight2D[vec4Index + 3] = right2D.y;
+        texcoordNormalization2D[vec2Index] = texcoordNormalization2DX * rightPlaneSide;
+        texcoordNormalization = texcoordNormalization2DY * topBottomSide;
+        if (texcoordNormalization === 0 && topBottomSide < 0) {
+          texcoordNormalization = 9;
+        }
+        texcoordNormalization2D[vec2Index + 1] = texcoordNormalization;
+      }
+    }
+    const adjustHeightStartBottom = adjustHeightStartBottomScratch;
+    const adjustHeightEndBottom = adjustHeightEndBottomScratch;
+    const adjustHeightStartTop = adjustHeightStartTopScratch;
+    const adjustHeightEndTop = adjustHeightEndTopScratch;
+    const getHeightsRectangle = Rectangle_default.fromCartographicArray(
+      getHeightCartographics,
+      getHeightRectangleScratch
+    );
+    const minMaxHeights = ApproximateTerrainHeights_default.getMinimumMaximumHeights(
+      getHeightsRectangle,
+      ellipsoid
+    );
+    const minHeight = minMaxHeights.minimumTerrainHeight;
+    const maxHeight = minMaxHeights.maximumTerrainHeight;
+    sumHeights += Math.abs(minHeight);
+    sumHeights += Math.abs(maxHeight);
+    adjustHeights(
+      startBottom,
+      startTop,
+      minHeight,
+      maxHeight,
+      adjustHeightStartBottom,
+      adjustHeightStartTop
+    );
+    adjustHeights(
+      endBottom,
+      endTop,
+      minHeight,
+      maxHeight,
+      adjustHeightEndBottom,
+      adjustHeightEndTop
+    );
+    let normalNudge = Cartesian3_default.multiplyByScalar(
+      rightNormal,
+      Math_default.EPSILON5,
+      normalNudgeScratch
+    );
+    Cartesian3_default.add(
+      adjustHeightStartBottom,
+      normalNudge,
+      adjustHeightStartBottom
+    );
+    Cartesian3_default.add(adjustHeightEndBottom, normalNudge, adjustHeightEndBottom);
+    Cartesian3_default.add(adjustHeightStartTop, normalNudge, adjustHeightStartTop);
+    Cartesian3_default.add(adjustHeightEndTop, normalNudge, adjustHeightEndTop);
+    nudgeXZ(adjustHeightStartBottom, adjustHeightEndBottom);
+    nudgeXZ(adjustHeightStartTop, adjustHeightEndTop);
+    Cartesian3_default.pack(adjustHeightStartBottom, positionsArray, vec3sWriteIndex);
+    Cartesian3_default.pack(adjustHeightEndBottom, positionsArray, vec3sWriteIndex + 3);
+    Cartesian3_default.pack(adjustHeightEndTop, positionsArray, vec3sWriteIndex + 6);
+    Cartesian3_default.pack(adjustHeightStartTop, positionsArray, vec3sWriteIndex + 9);
+    normalNudge = Cartesian3_default.multiplyByScalar(
+      rightNormal,
+      -2 * Math_default.EPSILON5,
+      normalNudgeScratch
+    );
+    Cartesian3_default.add(
+      adjustHeightStartBottom,
+      normalNudge,
+      adjustHeightStartBottom
+    );
+    Cartesian3_default.add(adjustHeightEndBottom, normalNudge, adjustHeightEndBottom);
+    Cartesian3_default.add(adjustHeightStartTop, normalNudge, adjustHeightStartTop);
+    Cartesian3_default.add(adjustHeightEndTop, normalNudge, adjustHeightEndTop);
+    nudgeXZ(adjustHeightStartBottom, adjustHeightEndBottom);
+    nudgeXZ(adjustHeightStartTop, adjustHeightEndTop);
+    Cartesian3_default.pack(
+      adjustHeightStartBottom,
+      positionsArray,
+      vec3sWriteIndex + 12
+    );
+    Cartesian3_default.pack(
+      adjustHeightEndBottom,
+      positionsArray,
+      vec3sWriteIndex + 15
+    );
+    Cartesian3_default.pack(adjustHeightEndTop, positionsArray, vec3sWriteIndex + 18);
+    Cartesian3_default.pack(adjustHeightStartTop, positionsArray, vec3sWriteIndex + 21);
+    cartographicsIndex += 2;
+    index += 3;
+    vec2sWriteIndex += 16;
+    vec3sWriteIndex += 24;
+    vec4sWriteIndex += 32;
+    lengthSoFar3D += segmentLength3D;
+    lengthSoFar2D += segmentLength2D;
+  }
+  index = 0;
+  let indexOffset = 0;
+  for (i = 0; i < segmentCount; i++) {
+    for (j = 0; j < REFERENCE_INDICES_LENGTH; j++) {
+      indices[index + j] = REFERENCE_INDICES[j] + indexOffset;
+    }
+    indexOffset += 8;
+    index += REFERENCE_INDICES_LENGTH;
+  }
+  const boundingSpheres = scratchBoundingSpheres;
+  BoundingSphere_default.fromVertices(
+    bottomPositionsArray,
+    Cartesian3_default.ZERO,
+    3,
+    boundingSpheres[0]
+  );
+  BoundingSphere_default.fromVertices(
+    topPositionsArray,
+    Cartesian3_default.ZERO,
+    3,
+    boundingSpheres[1]
+  );
+  const boundingSphere = BoundingSphere_default.fromBoundingSpheres(boundingSpheres);
+  boundingSphere.radius += sumHeights / (segmentCount * 2);
+  const attributes = {
+    position: new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.DOUBLE,
+      componentsPerAttribute: 3,
+      normalize: false,
+      values: positionsArray
+    }),
+    startHiAndForwardOffsetX: getVec4GeometryAttribute(
+      startHiAndForwardOffsetX
+    ),
+    startLoAndForwardOffsetY: getVec4GeometryAttribute(
+      startLoAndForwardOffsetY
+    ),
+    startNormalAndForwardOffsetZ: getVec4GeometryAttribute(
+      startNormalAndForwardOffsetZ
+    ),
+    endNormalAndTextureCoordinateNormalizationX: getVec4GeometryAttribute(
+      endNormalAndTextureCoordinateNormalizationX
+    ),
+    rightNormalAndTextureCoordinateNormalizationY: getVec4GeometryAttribute(
+      rightNormalAndTextureCoordinateNormalizationY
+    )
+  };
+  if (compute2dAttributes) {
+    attributes.startHiLo2D = getVec4GeometryAttribute(startHiLo2D);
+    attributes.offsetAndRight2D = getVec4GeometryAttribute(offsetAndRight2D);
+    attributes.startEndNormals2D = getVec4GeometryAttribute(startEndNormals2D);
+    attributes.texcoordNormalization2D = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 2,
+      normalize: false,
+      values: texcoordNormalization2D
+    });
+  }
+  return new Geometry_default({
+    attributes,
+    indices,
+    boundingSphere
+  });
+}
+function getVec4GeometryAttribute(typedArray) {
+  return new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.FLOAT,
+    componentsPerAttribute: 4,
+    normalize: false,
+    values: typedArray
+  });
+}
+GroundPolylineGeometry._projectNormal = projectNormal;
+var GroundPolylineGeometry_default = GroundPolylineGeometry;
+
+// packages/engine/Source/Workers/createGroundPolylineGeometry.js
+function createGroundPolylineGeometry(groundPolylineGeometry, offset) {
+  return ApproximateTerrainHeights_default.initialize().then(function() {
+    if (defined_default(offset)) {
+      groundPolylineGeometry = GroundPolylineGeometry_default.unpack(
+        groundPolylineGeometry,
+        offset
+      );
+    }
+    return GroundPolylineGeometry_default.createGeometry(groundPolylineGeometry);
+  });
+}
+var createGroundPolylineGeometry_default = createGroundPolylineGeometry;
+export {
+  createGroundPolylineGeometry_default as default
+};

public/assets/cesium/Workers/createPlaneGeometry.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 {
+  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 "./chunk-6SQMLVGV.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian3_default
+} from "./chunk-FFLMY4TE.js";
+import "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.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/PlaneGeometry.js
+function PlaneGeometry(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
+  this._vertexFormat = vertexFormat;
+  this._workerName = "createPlaneGeometry";
+}
+PlaneGeometry.packedLength = VertexFormat_default.packedLength;
+PlaneGeometry.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
+  return array;
+};
+var scratchVertexFormat = new VertexFormat_default();
+var scratchOptions = {
+  vertexFormat: scratchVertexFormat
+};
+PlaneGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const vertexFormat = VertexFormat_default.unpack(
+    array,
+    startingIndex,
+    scratchVertexFormat
+  );
+  if (!defined_default(result)) {
+    return new PlaneGeometry(scratchOptions);
+  }
+  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
+  return result;
+};
+var min = new Cartesian3_default(-0.5, -0.5, 0);
+var max = new Cartesian3_default(0.5, 0.5, 0);
+PlaneGeometry.createGeometry = function(planeGeometry) {
+  const vertexFormat = planeGeometry._vertexFormat;
+  const attributes = new GeometryAttributes_default();
+  let indices;
+  let positions;
+  if (vertexFormat.position) {
+    positions = new Float64Array(4 * 3);
+    positions[0] = min.x;
+    positions[1] = min.y;
+    positions[2] = 0;
+    positions[3] = max.x;
+    positions[4] = min.y;
+    positions[5] = 0;
+    positions[6] = max.x;
+    positions[7] = max.y;
+    positions[8] = 0;
+    positions[9] = min.x;
+    positions[10] = max.y;
+    positions[11] = 0;
+    attributes.position = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.DOUBLE,
+      componentsPerAttribute: 3,
+      values: positions
+    });
+    if (vertexFormat.normal) {
+      const normals = new Float32Array(4 * 3);
+      normals[0] = 0;
+      normals[1] = 0;
+      normals[2] = 1;
+      normals[3] = 0;
+      normals[4] = 0;
+      normals[5] = 1;
+      normals[6] = 0;
+      normals[7] = 0;
+      normals[8] = 1;
+      normals[9] = 0;
+      normals[10] = 0;
+      normals[11] = 1;
+      attributes.normal = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.FLOAT,
+        componentsPerAttribute: 3,
+        values: normals
+      });
+    }
+    if (vertexFormat.st) {
+      const texCoords = new Float32Array(4 * 2);
+      texCoords[0] = 0;
+      texCoords[1] = 0;
+      texCoords[2] = 1;
+      texCoords[3] = 0;
+      texCoords[4] = 1;
+      texCoords[5] = 1;
+      texCoords[6] = 0;
+      texCoords[7] = 1;
+      attributes.st = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.FLOAT,
+        componentsPerAttribute: 2,
+        values: texCoords
+      });
+    }
+    if (vertexFormat.tangent) {
+      const tangents = new Float32Array(4 * 3);
+      tangents[0] = 1;
+      tangents[1] = 0;
+      tangents[2] = 0;
+      tangents[3] = 1;
+      tangents[4] = 0;
+      tangents[5] = 0;
+      tangents[6] = 1;
+      tangents[7] = 0;
+      tangents[8] = 0;
+      tangents[9] = 1;
+      tangents[10] = 0;
+      tangents[11] = 0;
+      attributes.tangent = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.FLOAT,
+        componentsPerAttribute: 3,
+        values: tangents
+      });
+    }
+    if (vertexFormat.bitangent) {
+      const bitangents = new Float32Array(4 * 3);
+      bitangents[0] = 0;
+      bitangents[1] = 1;
+      bitangents[2] = 0;
+      bitangents[3] = 0;
+      bitangents[4] = 1;
+      bitangents[5] = 0;
+      bitangents[6] = 0;
+      bitangents[7] = 1;
+      bitangents[8] = 0;
+      bitangents[9] = 0;
+      bitangents[10] = 1;
+      bitangents[11] = 0;
+      attributes.bitangent = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.FLOAT,
+        componentsPerAttribute: 3,
+        values: bitangents
+      });
+    }
+    indices = new Uint16Array(2 * 3);
+    indices[0] = 0;
+    indices[1] = 1;
+    indices[2] = 2;
+    indices[3] = 0;
+    indices[4] = 2;
+    indices[5] = 3;
+  }
+  return new Geometry_default({
+    attributes,
+    indices,
+    primitiveType: PrimitiveType_default.TRIANGLES,
+    boundingSphere: new BoundingSphere_default(Cartesian3_default.ZERO, Math.sqrt(2))
+  });
+};
+var PlaneGeometry_default = PlaneGeometry;
+
+// packages/engine/Source/Workers/createPlaneGeometry.js
+function createPlaneGeometry(planeGeometry, offset) {
+  if (defined_default(offset)) {
+    planeGeometry = PlaneGeometry_default.unpack(planeGeometry, offset);
+  }
+  return PlaneGeometry_default.createGeometry(planeGeometry);
+}
+var createPlaneGeometry_default = createPlaneGeometry;
+export {
+  createPlaneGeometry_default as default
+};

public/assets/cesium/Workers/createPlaneOutlineGeometry.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 {
+  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 "./chunk-6SQMLVGV.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian3_default
+} from "./chunk-FFLMY4TE.js";
+import "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.js";
+import "./chunk-U5HSOKPQ.js";
+import {
+  Check_default
+} from "./chunk-P6TRGU3S.js";
+import {
+  defined_default
+} from "./chunk-YCDZX5LS.js";
+
+// packages/engine/Source/Core/PlaneOutlineGeometry.js
+function PlaneOutlineGeometry() {
+  this._workerName = "createPlaneOutlineGeometry";
+}
+PlaneOutlineGeometry.packedLength = 0;
+PlaneOutlineGeometry.pack = function(value, array) {
+  Check_default.defined("value", value);
+  Check_default.defined("array", array);
+  return array;
+};
+PlaneOutlineGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  if (!defined_default(result)) {
+    return new PlaneOutlineGeometry();
+  }
+  return result;
+};
+var min = new Cartesian3_default(-0.5, -0.5, 0);
+var max = new Cartesian3_default(0.5, 0.5, 0);
+PlaneOutlineGeometry.createGeometry = function() {
+  const attributes = new GeometryAttributes_default();
+  const indices = new Uint16Array(4 * 2);
+  const positions = new Float64Array(4 * 3);
+  positions[0] = min.x;
+  positions[1] = min.y;
+  positions[2] = min.z;
+  positions[3] = max.x;
+  positions[4] = min.y;
+  positions[5] = min.z;
+  positions[6] = max.x;
+  positions[7] = max.y;
+  positions[8] = min.z;
+  positions[9] = min.x;
+  positions[10] = max.y;
+  positions[11] = min.z;
+  attributes.position = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.DOUBLE,
+    componentsPerAttribute: 3,
+    values: positions
+  });
+  indices[0] = 0;
+  indices[1] = 1;
+  indices[2] = 1;
+  indices[3] = 2;
+  indices[4] = 2;
+  indices[5] = 3;
+  indices[6] = 3;
+  indices[7] = 0;
+  return new Geometry_default({
+    attributes,
+    indices,
+    primitiveType: PrimitiveType_default.LINES,
+    boundingSphere: new BoundingSphere_default(Cartesian3_default.ZERO, Math.sqrt(2))
+  });
+};
+var PlaneOutlineGeometry_default = PlaneOutlineGeometry;
+
+// packages/engine/Source/Workers/createPlaneOutlineGeometry.js
+function createPlaneOutlineGeometry(planeGeometry, offset) {
+  if (defined_default(offset)) {
+    planeGeometry = PlaneOutlineGeometry_default.unpack(planeGeometry, offset);
+  }
+  return PlaneOutlineGeometry_default.createGeometry(planeGeometry);
+}
+var createPlaneOutlineGeometry_default = createPlaneOutlineGeometry;
+export {
+  createPlaneOutlineGeometry_default as default
+};

public/assets/cesium/Workers/createPolygonGeometry.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 {
+  BoundingRectangle_default
+} from "./chunk-44QAAS4P.js";
+import {
+  PolygonGeometryLibrary_default
+} from "./chunk-IZJ42N4W.js";
+import {
+  ArcType_default
+} from "./chunk-XWOUPGUF.js";
+import {
+  GeometryInstance_default
+} from "./chunk-YSIJTJ7N.js";
+import {
+  GeometryPipeline_default
+} from "./chunk-7ZZ5LMZY.js";
+import "./chunk-LJ2JQHJT.js";
+import "./chunk-NGZJIN5Z.js";
+import {
+  GeometryOffsetAttribute_default
+} from "./chunk-GBT7MJ6X.js";
+import {
+  VertexFormat_default
+} from "./chunk-JBSKHTNX.js";
+import {
+  EllipsoidTangentPlane_default
+} from "./chunk-YK3QIKY7.js";
+import "./chunk-NDDI2LWR.js";
+import {
+  PolygonPipeline_default,
+  WindingOrder_default
+} from "./chunk-TI3TRKIC.js";
+import "./chunk-57H6I3SV.js";
+import "./chunk-JSQJDZI4.js";
+import {
+  IntersectionTests_default,
+  Ray_default
+} from "./chunk-QQOZO7KO.js";
+import "./chunk-EDLRS3AW.js";
+import {
+  IndexDatatype_default
+} from "./chunk-C4WPMOKT.js";
+import "./chunk-X7IQYYHF.js";
+import {
+  GeometryAttribute_default,
+  Geometry_default
+} from "./chunk-JXVLNVXC.js";
+import {
+  BoundingSphere_default
+} from "./chunk-KHZNBFOH.js";
+import {
+  Quaternion_default,
+  Rectangle_default
+} from "./chunk-6SQMLVGV.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian2_default,
+  Cartesian3_default,
+  Cartographic_default,
+  Ellipsoid_default,
+  Matrix3_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.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/Stereographic.js
+function Stereographic(position, tangentPlane) {
+  this.position = position;
+  if (!defined_default(this.position)) {
+    this.position = new Cartesian2_default();
+  }
+  this.tangentPlane = tangentPlane;
+  if (!defined_default(this.tangentPlane)) {
+    this.tangentPlane = Stereographic.NORTH_POLE_TANGENT_PLANE;
+  }
+}
+Object.defineProperties(Stereographic.prototype, {
+  /**
+   * Gets the ellipsoid.
+   * @memberof Stereographic.prototype
+   * @type {Ellipsoid}
+   */
+  ellipsoid: {
+    get: function() {
+      return this.tangentPlane.ellipsoid;
+    }
+  },
+  /**
+   * Gets the x coordinate
+   * @memberof Stereographic.prototype
+   * @type {number}
+   */
+  x: {
+    get: function() {
+      return this.position.x;
+    }
+  },
+  /**
+   * Gets the y coordinate
+   * @memberof Stereographic.prototype
+   * @type {number}
+   */
+  y: {
+    get: function() {
+      return this.position.y;
+    }
+  },
+  /**
+   * Computes the conformal latitude, or the ellipsoidal latitude projected onto an arbitrary sphere.
+   * @memberof Stereographic.prototype
+   * @type {number}
+   */
+  conformalLatitude: {
+    get: function() {
+      const r = Cartesian2_default.magnitude(this.position);
+      const d = 2 * this.ellipsoid.maximumRadius;
+      const sign = this.tangentPlane.plane.normal.z;
+      return sign * (Math_default.PI_OVER_TWO - 2 * Math.atan2(r, d));
+    }
+  },
+  /**
+   * Computes the longitude
+   * @memberof Stereographic.prototype
+   * @type {number}
+   */
+  longitude: {
+    get: function() {
+      let longitude = Math_default.PI_OVER_TWO + Math.atan2(this.y, this.x);
+      if (longitude > Math.PI) {
+        longitude -= Math_default.TWO_PI;
+      }
+      return longitude;
+    }
+  }
+});
+var scratchCartographic = new Cartographic_default();
+var scratchCartesian = new Cartesian3_default();
+Stereographic.prototype.getLatitude = function(ellipsoid) {
+  if (!defined_default(ellipsoid)) {
+    ellipsoid = Ellipsoid_default.default;
+  }
+  scratchCartographic.latitude = this.conformalLatitude;
+  scratchCartographic.longitude = this.longitude;
+  scratchCartographic.height = 0;
+  const cartesian = this.ellipsoid.cartographicToCartesian(
+    scratchCartographic,
+    scratchCartesian
+  );
+  ellipsoid.cartesianToCartographic(cartesian, scratchCartographic);
+  return scratchCartographic.latitude;
+};
+var scratchProjectPointOntoPlaneRay = new Ray_default();
+var scratchProjectPointOntoPlaneRayDirection = new Cartesian3_default();
+var scratchProjectPointOntoPlaneCartesian3 = new Cartesian3_default();
+Stereographic.fromCartesian = function(cartesian, result) {
+  Check_default.defined("cartesian", cartesian);
+  const sign = Math_default.signNotZero(cartesian.z);
+  let tangentPlane = Stereographic.NORTH_POLE_TANGENT_PLANE;
+  let origin = Stereographic.SOUTH_POLE;
+  if (sign < 0) {
+    tangentPlane = Stereographic.SOUTH_POLE_TANGENT_PLANE;
+    origin = Stereographic.NORTH_POLE;
+  }
+  const ray = scratchProjectPointOntoPlaneRay;
+  ray.origin = tangentPlane.ellipsoid.scaleToGeocentricSurface(
+    cartesian,
+    ray.origin
+  );
+  ray.direction = Cartesian3_default.subtract(
+    ray.origin,
+    origin,
+    scratchProjectPointOntoPlaneRayDirection
+  );
+  Cartesian3_default.normalize(ray.direction, ray.direction);
+  const intersectionPoint = IntersectionTests_default.rayPlane(
+    ray,
+    tangentPlane.plane,
+    scratchProjectPointOntoPlaneCartesian3
+  );
+  const v = Cartesian3_default.subtract(intersectionPoint, origin, intersectionPoint);
+  const x = Cartesian3_default.dot(tangentPlane.xAxis, v);
+  const y = sign * Cartesian3_default.dot(tangentPlane.yAxis, v);
+  if (!defined_default(result)) {
+    return new Stereographic(new Cartesian2_default(x, y), tangentPlane);
+  }
+  result.position = new Cartesian2_default(x, y);
+  result.tangentPlane = tangentPlane;
+  return result;
+};
+Stereographic.fromCartesianArray = 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] = Stereographic.fromCartesian(cartesians[i], result[i]);
+  }
+  return result;
+};
+Stereographic.clone = function(stereographic, result) {
+  if (!defined_default(stereographic)) {
+    return void 0;
+  }
+  if (!defined_default(result)) {
+    return new Stereographic(
+      stereographic.position,
+      stereographic.tangentPlane
+    );
+  }
+  result.position = stereographic.position;
+  result.tangentPlane = stereographic.tangentPlane;
+  return result;
+};
+Stereographic.HALF_UNIT_SPHERE = Object.freeze(new Ellipsoid_default(0.5, 0.5, 0.5));
+Stereographic.NORTH_POLE = Object.freeze(new Cartesian3_default(0, 0, 0.5));
+Stereographic.SOUTH_POLE = Object.freeze(new Cartesian3_default(0, 0, -0.5));
+Stereographic.NORTH_POLE_TANGENT_PLANE = Object.freeze(
+  new EllipsoidTangentPlane_default(
+    Stereographic.NORTH_POLE,
+    Stereographic.HALF_UNIT_SPHERE
+  )
+);
+Stereographic.SOUTH_POLE_TANGENT_PLANE = Object.freeze(
+  new EllipsoidTangentPlane_default(
+    Stereographic.SOUTH_POLE,
+    Stereographic.HALF_UNIT_SPHERE
+  )
+);
+var Stereographic_default = Stereographic;
+
+// packages/engine/Source/Core/PolygonGeometry.js
+var scratchCarto1 = new Cartographic_default();
+var scratchCarto2 = new Cartographic_default();
+function adjustPosHeightsForNormal(position, p1, p2, ellipsoid) {
+  const carto1 = ellipsoid.cartesianToCartographic(position, scratchCarto1);
+  const height = carto1.height;
+  const p1Carto = ellipsoid.cartesianToCartographic(p1, scratchCarto2);
+  p1Carto.height = height;
+  ellipsoid.cartographicToCartesian(p1Carto, p1);
+  const p2Carto = ellipsoid.cartesianToCartographic(p2, scratchCarto2);
+  p2Carto.height = height - 100;
+  ellipsoid.cartographicToCartesian(p2Carto, p2);
+}
+var scratchBoundingRectangle = new BoundingRectangle_default();
+var scratchPosition = new Cartesian3_default();
+var scratchNormal = new Cartesian3_default();
+var scratchTangent = new Cartesian3_default();
+var scratchBitangent = new Cartesian3_default();
+var p1Scratch = new Cartesian3_default();
+var p2Scratch = new Cartesian3_default();
+var scratchPerPosNormal = new Cartesian3_default();
+var scratchPerPosTangent = new Cartesian3_default();
+var scratchPerPosBitangent = new Cartesian3_default();
+var appendTextureCoordinatesOrigin = new Cartesian2_default();
+var appendTextureCoordinatesCartesian2 = new Cartesian2_default();
+var appendTextureCoordinatesCartesian3 = new Cartesian3_default();
+var appendTextureCoordinatesQuaternion = new Quaternion_default();
+var appendTextureCoordinatesMatrix3 = new Matrix3_default();
+var tangentMatrixScratch = new Matrix3_default();
+function computeAttributes(options) {
+  const vertexFormat = options.vertexFormat;
+  const geometry = options.geometry;
+  const shadowVolume = options.shadowVolume;
+  const flatPositions = geometry.attributes.position.values;
+  const flatTexcoords = defined_default(geometry.attributes.st) ? geometry.attributes.st.values : void 0;
+  let length = flatPositions.length;
+  const wall = options.wall;
+  const top = options.top || wall;
+  const bottom = options.bottom || wall;
+  if (vertexFormat.st || vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent || shadowVolume) {
+    const boundingRectangle = options.boundingRectangle;
+    const rotationAxis = options.rotationAxis;
+    const projectTo2d = options.projectTo2d;
+    const ellipsoid = options.ellipsoid;
+    const stRotation = options.stRotation;
+    const perPositionHeight = options.perPositionHeight;
+    const origin = appendTextureCoordinatesOrigin;
+    origin.x = boundingRectangle.x;
+    origin.y = boundingRectangle.y;
+    const textureCoordinates = vertexFormat.st ? new Float32Array(2 * (length / 3)) : void 0;
+    let normals;
+    if (vertexFormat.normal) {
+      if (perPositionHeight && top && !wall) {
+        normals = geometry.attributes.normal.values;
+      } else {
+        normals = new Float32Array(length);
+      }
+    }
+    const tangents = vertexFormat.tangent ? new Float32Array(length) : void 0;
+    const bitangents = vertexFormat.bitangent ? new Float32Array(length) : void 0;
+    const extrudeNormals = shadowVolume ? new Float32Array(length) : void 0;
+    let textureCoordIndex = 0;
+    let attrIndex = 0;
+    let normal = scratchNormal;
+    let tangent = scratchTangent;
+    let bitangent = scratchBitangent;
+    let recomputeNormal = true;
+    let textureMatrix = appendTextureCoordinatesMatrix3;
+    let tangentRotationMatrix = tangentMatrixScratch;
+    if (stRotation !== 0) {
+      let rotation = Quaternion_default.fromAxisAngle(
+        rotationAxis,
+        stRotation,
+        appendTextureCoordinatesQuaternion
+      );
+      textureMatrix = Matrix3_default.fromQuaternion(rotation, textureMatrix);
+      rotation = Quaternion_default.fromAxisAngle(
+        rotationAxis,
+        -stRotation,
+        appendTextureCoordinatesQuaternion
+      );
+      tangentRotationMatrix = Matrix3_default.fromQuaternion(
+        rotation,
+        tangentRotationMatrix
+      );
+    } else {
+      textureMatrix = Matrix3_default.clone(Matrix3_default.IDENTITY, textureMatrix);
+      tangentRotationMatrix = Matrix3_default.clone(
+        Matrix3_default.IDENTITY,
+        tangentRotationMatrix
+      );
+    }
+    let bottomOffset = 0;
+    let bottomOffset2 = 0;
+    if (top && bottom) {
+      bottomOffset = length / 2;
+      bottomOffset2 = length / 3;
+      length /= 2;
+    }
+    for (let i = 0; i < length; i += 3) {
+      const position = Cartesian3_default.fromArray(
+        flatPositions,
+        i,
+        appendTextureCoordinatesCartesian3
+      );
+      if (vertexFormat.st) {
+        if (!defined_default(flatTexcoords)) {
+          let p = Matrix3_default.multiplyByVector(
+            textureMatrix,
+            position,
+            scratchPosition
+          );
+          p = ellipsoid.scaleToGeodeticSurface(p, p);
+          const st = projectTo2d([p], appendTextureCoordinatesCartesian2)[0];
+          Cartesian2_default.subtract(st, origin, st);
+          const stx = Math_default.clamp(st.x / boundingRectangle.width, 0, 1);
+          const sty = Math_default.clamp(st.y / boundingRectangle.height, 0, 1);
+          if (bottom) {
+            textureCoordinates[textureCoordIndex + bottomOffset2] = stx;
+            textureCoordinates[textureCoordIndex + 1 + bottomOffset2] = sty;
+          }
+          if (top) {
+            textureCoordinates[textureCoordIndex] = stx;
+            textureCoordinates[textureCoordIndex + 1] = sty;
+          }
+          textureCoordIndex += 2;
+        }
+      }
+      if (vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent || shadowVolume) {
+        const attrIndex1 = attrIndex + 1;
+        const attrIndex2 = attrIndex + 2;
+        if (wall) {
+          if (i + 3 < length) {
+            const p1 = Cartesian3_default.fromArray(flatPositions, i + 3, p1Scratch);
+            if (recomputeNormal) {
+              const p2 = Cartesian3_default.fromArray(
+                flatPositions,
+                i + length,
+                p2Scratch
+              );
+              if (perPositionHeight) {
+                adjustPosHeightsForNormal(position, p1, p2, ellipsoid);
+              }
+              Cartesian3_default.subtract(p1, position, p1);
+              Cartesian3_default.subtract(p2, position, p2);
+              normal = Cartesian3_default.normalize(
+                Cartesian3_default.cross(p2, p1, normal),
+                normal
+              );
+              recomputeNormal = false;
+            }
+            if (Cartesian3_default.equalsEpsilon(p1, position, Math_default.EPSILON10)) {
+              recomputeNormal = true;
+            }
+          }
+          if (vertexFormat.tangent || vertexFormat.bitangent) {
+            bitangent = ellipsoid.geodeticSurfaceNormal(position, bitangent);
+            if (vertexFormat.tangent) {
+              tangent = Cartesian3_default.normalize(
+                Cartesian3_default.cross(bitangent, normal, tangent),
+                tangent
+              );
+            }
+          }
+        } else {
+          normal = ellipsoid.geodeticSurfaceNormal(position, normal);
+          if (vertexFormat.tangent || vertexFormat.bitangent) {
+            if (perPositionHeight) {
+              scratchPerPosNormal = Cartesian3_default.fromArray(
+                normals,
+                attrIndex,
+                scratchPerPosNormal
+              );
+              scratchPerPosTangent = Cartesian3_default.cross(
+                Cartesian3_default.UNIT_Z,
+                scratchPerPosNormal,
+                scratchPerPosTangent
+              );
+              scratchPerPosTangent = Cartesian3_default.normalize(
+                Matrix3_default.multiplyByVector(
+                  tangentRotationMatrix,
+                  scratchPerPosTangent,
+                  scratchPerPosTangent
+                ),
+                scratchPerPosTangent
+              );
+              if (vertexFormat.bitangent) {
+                scratchPerPosBitangent = Cartesian3_default.normalize(
+                  Cartesian3_default.cross(
+                    scratchPerPosNormal,
+                    scratchPerPosTangent,
+                    scratchPerPosBitangent
+                  ),
+                  scratchPerPosBitangent
+                );
+              }
+            }
+            tangent = Cartesian3_default.cross(Cartesian3_default.UNIT_Z, normal, tangent);
+            tangent = Cartesian3_default.normalize(
+              Matrix3_default.multiplyByVector(tangentRotationMatrix, tangent, tangent),
+              tangent
+            );
+            if (vertexFormat.bitangent) {
+              bitangent = Cartesian3_default.normalize(
+                Cartesian3_default.cross(normal, tangent, bitangent),
+                bitangent
+              );
+            }
+          }
+        }
+        if (vertexFormat.normal) {
+          if (options.wall) {
+            normals[attrIndex + bottomOffset] = normal.x;
+            normals[attrIndex1 + bottomOffset] = normal.y;
+            normals[attrIndex2 + bottomOffset] = normal.z;
+          } else if (bottom) {
+            normals[attrIndex + bottomOffset] = -normal.x;
+            normals[attrIndex1 + bottomOffset] = -normal.y;
+            normals[attrIndex2 + bottomOffset] = -normal.z;
+          }
+          if (top && !perPositionHeight || wall) {
+            normals[attrIndex] = normal.x;
+            normals[attrIndex1] = normal.y;
+            normals[attrIndex2] = normal.z;
+          }
+        }
+        if (shadowVolume) {
+          if (wall) {
+            normal = ellipsoid.geodeticSurfaceNormal(position, normal);
+          }
+          extrudeNormals[attrIndex + bottomOffset] = -normal.x;
+          extrudeNormals[attrIndex1 + bottomOffset] = -normal.y;
+          extrudeNormals[attrIndex2 + bottomOffset] = -normal.z;
+        }
+        if (vertexFormat.tangent) {
+          if (options.wall) {
+            tangents[attrIndex + bottomOffset] = tangent.x;
+            tangents[attrIndex1 + bottomOffset] = tangent.y;
+            tangents[attrIndex2 + bottomOffset] = tangent.z;
+          } else if (bottom) {
+            tangents[attrIndex + bottomOffset] = -tangent.x;
+            tangents[attrIndex1 + bottomOffset] = -tangent.y;
+            tangents[attrIndex2 + bottomOffset] = -tangent.z;
+          }
+          if (top) {
+            if (perPositionHeight) {
+              tangents[attrIndex] = scratchPerPosTangent.x;
+              tangents[attrIndex1] = scratchPerPosTangent.y;
+              tangents[attrIndex2] = scratchPerPosTangent.z;
+            } else {
+              tangents[attrIndex] = tangent.x;
+              tangents[attrIndex1] = tangent.y;
+              tangents[attrIndex2] = tangent.z;
+            }
+          }
+        }
+        if (vertexFormat.bitangent) {
+          if (bottom) {
+            bitangents[attrIndex + bottomOffset] = bitangent.x;
+            bitangents[attrIndex1 + bottomOffset] = bitangent.y;
+            bitangents[attrIndex2 + bottomOffset] = bitangent.z;
+          }
+          if (top) {
+            if (perPositionHeight) {
+              bitangents[attrIndex] = scratchPerPosBitangent.x;
+              bitangents[attrIndex1] = scratchPerPosBitangent.y;
+              bitangents[attrIndex2] = scratchPerPosBitangent.z;
+            } else {
+              bitangents[attrIndex] = bitangent.x;
+              bitangents[attrIndex1] = bitangent.y;
+              bitangents[attrIndex2] = bitangent.z;
+            }
+          }
+        }
+        attrIndex += 3;
+      }
+    }
+    if (vertexFormat.st && !defined_default(flatTexcoords)) {
+      geometry.attributes.st = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.FLOAT,
+        componentsPerAttribute: 2,
+        values: textureCoordinates
+      });
+    }
+    if (vertexFormat.normal) {
+      geometry.attributes.normal = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.FLOAT,
+        componentsPerAttribute: 3,
+        values: normals
+      });
+    }
+    if (vertexFormat.tangent) {
+      geometry.attributes.tangent = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.FLOAT,
+        componentsPerAttribute: 3,
+        values: tangents
+      });
+    }
+    if (vertexFormat.bitangent) {
+      geometry.attributes.bitangent = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.FLOAT,
+        componentsPerAttribute: 3,
+        values: bitangents
+      });
+    }
+    if (shadowVolume) {
+      geometry.attributes.extrudeDirection = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.FLOAT,
+        componentsPerAttribute: 3,
+        values: extrudeNormals
+      });
+    }
+  }
+  if (options.extrude && defined_default(options.offsetAttribute)) {
+    const size = flatPositions.length / 3;
+    let offsetAttribute = new Uint8Array(size);
+    if (options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
+      if (top && bottom || wall) {
+        offsetAttribute = offsetAttribute.fill(1, 0, size / 2);
+      } else if (top) {
+        offsetAttribute = offsetAttribute.fill(1);
+      }
+    } else {
+      const offsetValue = options.offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+      offsetAttribute = offsetAttribute.fill(offsetValue);
+    }
+    geometry.attributes.applyOffset = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: offsetAttribute
+    });
+  }
+  return geometry;
+}
+var createGeometryFromPositionsExtrudedPositions = [];
+function createGeometryFromPositionsExtruded(ellipsoid, polygon2, textureCoordinates, granularity, hierarchy, perPositionHeight, closeTop, closeBottom, vertexFormat, arcType) {
+  const geos = {
+    walls: []
+  };
+  let i;
+  if (closeTop || closeBottom) {
+    const topGeo = PolygonGeometryLibrary_default.createGeometryFromPositions(
+      ellipsoid,
+      polygon2,
+      textureCoordinates,
+      granularity,
+      perPositionHeight,
+      vertexFormat,
+      arcType
+    );
+    const edgePoints = topGeo.attributes.position.values;
+    const indices = topGeo.indices;
+    let numPositions;
+    let newIndices;
+    if (closeTop && closeBottom) {
+      const topBottomPositions = edgePoints.concat(edgePoints);
+      numPositions = topBottomPositions.length / 3;
+      newIndices = IndexDatatype_default.createTypedArray(
+        numPositions,
+        indices.length * 2
+      );
+      newIndices.set(indices);
+      const ilength = indices.length;
+      const length = numPositions / 2;
+      for (i = 0; i < ilength; i += 3) {
+        const i0 = newIndices[i] + length;
+        const i1 = newIndices[i + 1] + length;
+        const i2 = newIndices[i + 2] + length;
+        newIndices[i + ilength] = i2;
+        newIndices[i + 1 + ilength] = i1;
+        newIndices[i + 2 + ilength] = i0;
+      }
+      topGeo.attributes.position.values = topBottomPositions;
+      if (perPositionHeight && vertexFormat.normal) {
+        const normals = topGeo.attributes.normal.values;
+        topGeo.attributes.normal.values = new Float32Array(
+          topBottomPositions.length
+        );
+        topGeo.attributes.normal.values.set(normals);
+      }
+      if (vertexFormat.st && defined_default(textureCoordinates)) {
+        const texcoords = topGeo.attributes.st.values;
+        topGeo.attributes.st.values = new Float32Array(numPositions * 2);
+        topGeo.attributes.st.values = texcoords.concat(texcoords);
+      }
+      topGeo.indices = newIndices;
+    } else if (closeBottom) {
+      numPositions = edgePoints.length / 3;
+      newIndices = IndexDatatype_default.createTypedArray(numPositions, indices.length);
+      for (i = 0; i < indices.length; i += 3) {
+        newIndices[i] = indices[i + 2];
+        newIndices[i + 1] = indices[i + 1];
+        newIndices[i + 2] = indices[i];
+      }
+      topGeo.indices = newIndices;
+    }
+    geos.topAndBottom = new GeometryInstance_default({
+      geometry: topGeo
+    });
+  }
+  let outerRing = hierarchy.outerRing;
+  const tangentPlane = EllipsoidTangentPlane_default.fromPoints(outerRing, ellipsoid);
+  let positions2D = tangentPlane.projectPointsOntoPlane(
+    outerRing,
+    createGeometryFromPositionsExtrudedPositions
+  );
+  let windingOrder = PolygonPipeline_default.computeWindingOrder2D(positions2D);
+  if (windingOrder === WindingOrder_default.CLOCKWISE) {
+    outerRing = outerRing.slice().reverse();
+  }
+  let wallGeo = PolygonGeometryLibrary_default.computeWallGeometry(
+    outerRing,
+    textureCoordinates,
+    ellipsoid,
+    granularity,
+    perPositionHeight,
+    arcType
+  );
+  geos.walls.push(
+    new GeometryInstance_default({
+      geometry: wallGeo
+    })
+  );
+  const holes = hierarchy.holes;
+  for (i = 0; i < holes.length; i++) {
+    let hole = holes[i];
+    positions2D = tangentPlane.projectPointsOntoPlane(
+      hole,
+      createGeometryFromPositionsExtrudedPositions
+    );
+    windingOrder = PolygonPipeline_default.computeWindingOrder2D(positions2D);
+    if (windingOrder === WindingOrder_default.COUNTER_CLOCKWISE) {
+      hole = hole.slice().reverse();
+    }
+    wallGeo = PolygonGeometryLibrary_default.computeWallGeometry(
+      hole,
+      textureCoordinates,
+      ellipsoid,
+      granularity,
+      perPositionHeight,
+      arcType
+    );
+    geos.walls.push(
+      new GeometryInstance_default({
+        geometry: wallGeo
+      })
+    );
+  }
+  return geos;
+}
+function PolygonGeometry(options) {
+  Check_default.typeOf.object("options", options);
+  Check_default.typeOf.object("options.polygonHierarchy", options.polygonHierarchy);
+  if (defined_default(options.perPositionHeight) && options.perPositionHeight && defined_default(options.height)) {
+    throw new DeveloperError_default(
+      "Cannot use both options.perPositionHeight and options.height"
+    );
+  }
+  if (defined_default(options.arcType) && options.arcType !== ArcType_default.GEODESIC && options.arcType !== ArcType_default.RHUMB) {
+    throw new DeveloperError_default(
+      "Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB."
+    );
+  }
+  const polygonHierarchy = options.polygonHierarchy;
+  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
+  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.default);
+  const granularity = defaultValue_default(
+    options.granularity,
+    Math_default.RADIANS_PER_DEGREE
+  );
+  const stRotation = defaultValue_default(options.stRotation, 0);
+  const textureCoordinates = options.textureCoordinates;
+  const perPositionHeight = defaultValue_default(options.perPositionHeight, false);
+  const perPositionHeightExtrude = perPositionHeight && defined_default(options.extrudedHeight);
+  let height = defaultValue_default(options.height, 0);
+  let extrudedHeight = defaultValue_default(options.extrudedHeight, height);
+  if (!perPositionHeightExtrude) {
+    const h = Math.max(height, extrudedHeight);
+    extrudedHeight = Math.min(height, extrudedHeight);
+    height = h;
+  }
+  this._vertexFormat = VertexFormat_default.clone(vertexFormat);
+  this._ellipsoid = Ellipsoid_default.clone(ellipsoid);
+  this._granularity = granularity;
+  this._stRotation = stRotation;
+  this._height = height;
+  this._extrudedHeight = extrudedHeight;
+  this._closeTop = defaultValue_default(options.closeTop, true);
+  this._closeBottom = defaultValue_default(options.closeBottom, true);
+  this._polygonHierarchy = polygonHierarchy;
+  this._perPositionHeight = perPositionHeight;
+  this._perPositionHeightExtrude = perPositionHeightExtrude;
+  this._shadowVolume = defaultValue_default(options.shadowVolume, false);
+  this._workerName = "createPolygonGeometry";
+  this._offsetAttribute = options.offsetAttribute;
+  this._arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
+  this._rectangle = void 0;
+  this._textureCoordinateRotationPoints = void 0;
+  this._textureCoordinates = textureCoordinates;
+  this.packedLength = PolygonGeometryLibrary_default.computeHierarchyPackedLength(
+    polygonHierarchy,
+    Cartesian3_default
+  ) + Ellipsoid_default.packedLength + VertexFormat_default.packedLength + (textureCoordinates ? PolygonGeometryLibrary_default.computeHierarchyPackedLength(
+    textureCoordinates,
+    Cartesian2_default
+  ) : 1) + 12;
+}
+PolygonGeometry.fromPositions = function(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  Check_default.defined("options.positions", options.positions);
+  const newOptions = {
+    polygonHierarchy: {
+      positions: options.positions
+    },
+    height: options.height,
+    extrudedHeight: options.extrudedHeight,
+    vertexFormat: options.vertexFormat,
+    stRotation: options.stRotation,
+    ellipsoid: options.ellipsoid,
+    granularity: options.granularity,
+    perPositionHeight: options.perPositionHeight,
+    closeTop: options.closeTop,
+    closeBottom: options.closeBottom,
+    offsetAttribute: options.offsetAttribute,
+    arcType: options.arcType,
+    textureCoordinates: options.textureCoordinates
+  };
+  return new PolygonGeometry(newOptions);
+};
+PolygonGeometry.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  startingIndex = PolygonGeometryLibrary_default.packPolygonHierarchy(
+    value._polygonHierarchy,
+    array,
+    startingIndex,
+    Cartesian3_default
+  );
+  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
+  startingIndex += Ellipsoid_default.packedLength;
+  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
+  startingIndex += VertexFormat_default.packedLength;
+  array[startingIndex++] = value._height;
+  array[startingIndex++] = value._extrudedHeight;
+  array[startingIndex++] = value._granularity;
+  array[startingIndex++] = value._stRotation;
+  array[startingIndex++] = value._perPositionHeightExtrude ? 1 : 0;
+  array[startingIndex++] = value._perPositionHeight ? 1 : 0;
+  array[startingIndex++] = value._closeTop ? 1 : 0;
+  array[startingIndex++] = value._closeBottom ? 1 : 0;
+  array[startingIndex++] = value._shadowVolume ? 1 : 0;
+  array[startingIndex++] = defaultValue_default(value._offsetAttribute, -1);
+  array[startingIndex++] = value._arcType;
+  if (defined_default(value._textureCoordinates)) {
+    startingIndex = PolygonGeometryLibrary_default.packPolygonHierarchy(
+      value._textureCoordinates,
+      array,
+      startingIndex,
+      Cartesian2_default
+    );
+  } else {
+    array[startingIndex++] = -1;
+  }
+  array[startingIndex++] = value.packedLength;
+  return array;
+};
+var scratchEllipsoid = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
+var scratchVertexFormat = new VertexFormat_default();
+var dummyOptions = {
+  polygonHierarchy: {}
+};
+PolygonGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const polygonHierarchy = PolygonGeometryLibrary_default.unpackPolygonHierarchy(
+    array,
+    startingIndex,
+    Cartesian3_default
+  );
+  startingIndex = polygonHierarchy.startingIndex;
+  delete polygonHierarchy.startingIndex;
+  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
+  startingIndex += Ellipsoid_default.packedLength;
+  const vertexFormat = VertexFormat_default.unpack(
+    array,
+    startingIndex,
+    scratchVertexFormat
+  );
+  startingIndex += VertexFormat_default.packedLength;
+  const height = array[startingIndex++];
+  const extrudedHeight = array[startingIndex++];
+  const granularity = array[startingIndex++];
+  const stRotation = array[startingIndex++];
+  const perPositionHeightExtrude = array[startingIndex++] === 1;
+  const perPositionHeight = array[startingIndex++] === 1;
+  const closeTop = array[startingIndex++] === 1;
+  const closeBottom = array[startingIndex++] === 1;
+  const shadowVolume = array[startingIndex++] === 1;
+  const offsetAttribute = array[startingIndex++];
+  const arcType = array[startingIndex++];
+  const textureCoordinates = array[startingIndex] === -1 ? void 0 : PolygonGeometryLibrary_default.unpackPolygonHierarchy(
+    array,
+    startingIndex,
+    Cartesian2_default
+  );
+  if (defined_default(textureCoordinates)) {
+    startingIndex = textureCoordinates.startingIndex;
+    delete textureCoordinates.startingIndex;
+  } else {
+    startingIndex++;
+  }
+  const packedLength = array[startingIndex++];
+  if (!defined_default(result)) {
+    result = new PolygonGeometry(dummyOptions);
+  }
+  result._polygonHierarchy = polygonHierarchy;
+  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
+  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
+  result._height = height;
+  result._extrudedHeight = extrudedHeight;
+  result._granularity = granularity;
+  result._stRotation = stRotation;
+  result._perPositionHeightExtrude = perPositionHeightExtrude;
+  result._perPositionHeight = perPositionHeight;
+  result._closeTop = closeTop;
+  result._closeBottom = closeBottom;
+  result._shadowVolume = shadowVolume;
+  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+  result._arcType = arcType;
+  result._textureCoordinates = textureCoordinates;
+  result.packedLength = packedLength;
+  return result;
+};
+var scratchCartesian0 = new Cartesian2_default();
+var scratchCartesian1 = new Cartesian2_default();
+var scratchPolarClosest = new Stereographic_default();
+function expandRectangle(polar, lastPolar, ellipsoid, arcType, polygon2, result) {
+  const longitude = polar.longitude;
+  const lonAdjusted = longitude >= 0 ? longitude : longitude + Math_default.TWO_PI;
+  polygon2.westOverIdl = Math.min(polygon2.westOverIdl, lonAdjusted);
+  polygon2.eastOverIdl = Math.max(polygon2.eastOverIdl, lonAdjusted);
+  result.west = Math.min(result.west, longitude);
+  result.east = Math.max(result.east, longitude);
+  const latitude = polar.getLatitude(ellipsoid);
+  let segmentLatitude = latitude;
+  result.south = Math.min(result.south, latitude);
+  result.north = Math.max(result.north, latitude);
+  if (arcType !== ArcType_default.RHUMB) {
+    const segment = Cartesian2_default.subtract(
+      lastPolar.position,
+      polar.position,
+      scratchCartesian0
+    );
+    const t = Cartesian2_default.dot(lastPolar.position, segment) / Cartesian2_default.dot(segment, segment);
+    if (t > 0 && t < 1) {
+      const projected = Cartesian2_default.add(
+        lastPolar.position,
+        Cartesian2_default.multiplyByScalar(segment, -t, segment),
+        scratchCartesian1
+      );
+      const closestPolar = Stereographic_default.clone(lastPolar, scratchPolarClosest);
+      closestPolar.position = projected;
+      const adjustedLatitude = closestPolar.getLatitude(ellipsoid);
+      result.south = Math.min(result.south, adjustedLatitude);
+      result.north = Math.max(result.north, adjustedLatitude);
+      if (Math.abs(latitude) > Math.abs(adjustedLatitude)) {
+        segmentLatitude = adjustedLatitude;
+      }
+    }
+  }
+  const direction = lastPolar.x * polar.y - polar.x * lastPolar.y;
+  let angle = Math.sign(direction);
+  if (angle !== 0) {
+    angle *= Cartesian2_default.angleBetween(lastPolar.position, polar.position);
+  }
+  if (segmentLatitude >= 0) {
+    polygon2.northAngle += angle;
+  }
+  if (segmentLatitude <= 0) {
+    polygon2.southAngle += angle;
+  }
+}
+var scratchPolar = new Stereographic_default();
+var scratchPolarPrevious = new Stereographic_default();
+var polygon = {
+  northAngle: 0,
+  southAngle: 0,
+  westOverIdl: 0,
+  eastOverIdl: 0
+};
+PolygonGeometry.computeRectangleFromPositions = function(positions, ellipsoid, arcType, result) {
+  Check_default.defined("positions", positions);
+  if (!defined_default(result)) {
+    result = new Rectangle_default();
+  }
+  if (positions.length < 3) {
+    return result;
+  }
+  result.west = Number.POSITIVE_INFINITY;
+  result.east = Number.NEGATIVE_INFINITY;
+  result.south = Number.POSITIVE_INFINITY;
+  result.north = Number.NEGATIVE_INFINITY;
+  polygon.northAngle = 0;
+  polygon.southAngle = 0;
+  polygon.westOverIdl = Number.POSITIVE_INFINITY;
+  polygon.eastOverIdl = Number.NEGATIVE_INFINITY;
+  const positionsLength = positions.length;
+  let lastPolarPosition = Stereographic_default.fromCartesian(
+    positions[0],
+    scratchPolarPrevious
+  );
+  for (let i = 1; i < positionsLength; i++) {
+    const polarPosition = Stereographic_default.fromCartesian(
+      positions[i],
+      scratchPolar
+    );
+    expandRectangle(
+      polarPosition,
+      lastPolarPosition,
+      ellipsoid,
+      arcType,
+      polygon,
+      result
+    );
+    lastPolarPosition = Stereographic_default.clone(polarPosition, lastPolarPosition);
+  }
+  expandRectangle(
+    Stereographic_default.fromCartesian(positions[0], scratchPolar),
+    lastPolarPosition,
+    ellipsoid,
+    arcType,
+    polygon,
+    result
+  );
+  if (result.east - result.west > polygon.eastOverIdl - polygon.westOverIdl) {
+    result.west = polygon.westOverIdl;
+    result.east = polygon.eastOverIdl;
+    if (result.east > Math_default.PI) {
+      result.east = result.east - Math_default.TWO_PI;
+    }
+    if (result.west > Math_default.PI) {
+      result.west = result.west - Math_default.TWO_PI;
+    }
+  }
+  if (Math_default.equalsEpsilon(
+    Math.abs(polygon.northAngle),
+    Math_default.TWO_PI,
+    Math_default.EPSILON10
+  )) {
+    result.north = Math_default.PI_OVER_TWO;
+    result.east = Math_default.PI;
+    result.west = -Math_default.PI;
+  }
+  if (Math_default.equalsEpsilon(
+    Math.abs(polygon.southAngle),
+    Math_default.TWO_PI,
+    Math_default.EPSILON10
+  )) {
+    result.south = -Math_default.PI_OVER_TWO;
+    result.east = Math_default.PI;
+    result.west = -Math_default.PI;
+  }
+  return result;
+};
+var scratchPolarForPlane = new Stereographic_default();
+function getTangentPlane(rectangle, positions, ellipsoid) {
+  if (rectangle.height >= Math_default.PI || rectangle.width >= Math_default.PI) {
+    const polar = Stereographic_default.fromCartesian(
+      positions[0],
+      scratchPolarForPlane
+    );
+    return polar.tangentPlane;
+  }
+  return EllipsoidTangentPlane_default.fromPoints(positions, ellipsoid);
+}
+var scratchCartographicCyllindrical = new Cartographic_default();
+function createProjectTo2d(rectangle, outerPositions, ellipsoid) {
+  return (positions, results) => {
+    if (rectangle.height >= Math_default.PI || rectangle.width >= Math_default.PI) {
+      if (rectangle.south < 0 && rectangle.north > 0) {
+        if (!defined_default(results)) {
+          results = [];
+        }
+        for (let i = 0; i < positions.length; ++i) {
+          const cartographic = ellipsoid.cartesianToCartographic(
+            positions[i],
+            scratchCartographicCyllindrical
+          );
+          results[i] = new Cartesian2_default(
+            cartographic.longitude / Math_default.PI,
+            cartographic.latitude / Math_default.PI_OVER_TWO
+          );
+        }
+        results.length = positions.length;
+        return results;
+      }
+      return Stereographic_default.fromCartesianArray(positions, results);
+    }
+    const tangentPlane = EllipsoidTangentPlane_default.fromPoints(
+      outerPositions,
+      ellipsoid
+    );
+    return tangentPlane.projectPointsOntoPlane(positions, results);
+  };
+}
+function createProjectPositionTo2d(rectangle, outerRing, ellipsoid) {
+  if (rectangle.height >= Math_default.PI || rectangle.width >= Math_default.PI) {
+    return (position, result) => {
+      if (rectangle.south < 0 && rectangle.north > 0) {
+        const cartographic = ellipsoid.cartesianToCartographic(
+          position,
+          scratchCartographicCyllindrical
+        );
+        if (!defined_default(result)) {
+          result = new Cartesian2_default();
+        }
+        result.x = cartographic.longitude / Math_default.PI;
+        result.y = cartographic.latitude / Math_default.PI_OVER_TWO;
+        return result;
+      }
+      return Stereographic_default.fromCartesian(position, result);
+    };
+  }
+  const tangentPlane = EllipsoidTangentPlane_default.fromPoints(outerRing, ellipsoid);
+  return (position, result) => {
+    return tangentPlane.projectPointsOntoPlane(position, result);
+  };
+}
+function createSplitPolygons(rectangle, ellipsoid, arcType, perPositionHeight) {
+  return (polygons, results) => {
+    if (!perPositionHeight && (rectangle.height >= Math_default.PI_OVER_TWO || rectangle.width >= 2 * Math_default.PI_OVER_THREE)) {
+      return PolygonGeometryLibrary_default.splitPolygonsOnEquator(
+        polygons,
+        ellipsoid,
+        arcType,
+        results
+      );
+    }
+    return polygons;
+  };
+}
+function computeBoundingRectangle(outerRing, rectangle, ellipsoid, stRotation) {
+  if (rectangle.height >= Math_default.PI || rectangle.width >= Math_default.PI) {
+    return BoundingRectangle_default.fromRectangle(
+      rectangle,
+      void 0,
+      scratchBoundingRectangle
+    );
+  }
+  const outerPositions = outerRing;
+  const tangentPlane = EllipsoidTangentPlane_default.fromPoints(
+    outerPositions,
+    ellipsoid
+  );
+  return PolygonGeometryLibrary_default.computeBoundingRectangle(
+    tangentPlane.plane.normal,
+    tangentPlane.projectPointOntoPlane.bind(tangentPlane),
+    outerPositions,
+    stRotation,
+    scratchBoundingRectangle
+  );
+}
+PolygonGeometry.createGeometry = function(polygonGeometry) {
+  const vertexFormat = polygonGeometry._vertexFormat;
+  const ellipsoid = polygonGeometry._ellipsoid;
+  const granularity = polygonGeometry._granularity;
+  const stRotation = polygonGeometry._stRotation;
+  const polygonHierarchy = polygonGeometry._polygonHierarchy;
+  const perPositionHeight = polygonGeometry._perPositionHeight;
+  const closeTop = polygonGeometry._closeTop;
+  const closeBottom = polygonGeometry._closeBottom;
+  const arcType = polygonGeometry._arcType;
+  const textureCoordinates = polygonGeometry._textureCoordinates;
+  const hasTextureCoordinates = defined_default(textureCoordinates);
+  const outerPositions = polygonHierarchy.positions;
+  if (outerPositions.length < 3) {
+    return;
+  }
+  const rectangle = polygonGeometry.rectangle;
+  const results = PolygonGeometryLibrary_default.polygonsFromHierarchy(
+    polygonHierarchy,
+    hasTextureCoordinates,
+    createProjectTo2d(rectangle, outerPositions, ellipsoid),
+    !perPositionHeight,
+    ellipsoid,
+    createSplitPolygons(rectangle, ellipsoid, arcType, perPositionHeight)
+  );
+  const hierarchy = results.hierarchy;
+  const polygons = results.polygons;
+  const dummyFunction = function(identity) {
+    return identity;
+  };
+  const textureCoordinatePolygons = hasTextureCoordinates ? PolygonGeometryLibrary_default.polygonsFromHierarchy(
+    textureCoordinates,
+    true,
+    dummyFunction,
+    false,
+    ellipsoid
+  ).polygons : void 0;
+  if (hierarchy.length === 0) {
+    return;
+  }
+  const outerRing = hierarchy[0].outerRing;
+  const boundingRectangle = computeBoundingRectangle(
+    outerRing,
+    rectangle,
+    ellipsoid,
+    stRotation
+  );
+  const geometries = [];
+  const height = polygonGeometry._height;
+  const extrudedHeight = polygonGeometry._extrudedHeight;
+  const extrude = polygonGeometry._perPositionHeightExtrude || !Math_default.equalsEpsilon(height, extrudedHeight, 0, Math_default.EPSILON2);
+  const options = {
+    perPositionHeight,
+    vertexFormat,
+    geometry: void 0,
+    rotationAxis: getTangentPlane(rectangle, outerRing, ellipsoid).plane.normal,
+    projectTo2d: createProjectPositionTo2d(rectangle, outerRing, ellipsoid),
+    boundingRectangle,
+    ellipsoid,
+    stRotation,
+    textureCoordinates: void 0,
+    bottom: false,
+    top: true,
+    wall: false,
+    extrude: false,
+    arcType
+  };
+  let i;
+  if (extrude) {
+    options.extrude = true;
+    options.top = closeTop;
+    options.bottom = closeBottom;
+    options.shadowVolume = polygonGeometry._shadowVolume;
+    options.offsetAttribute = polygonGeometry._offsetAttribute;
+    for (i = 0; i < polygons.length; i++) {
+      const splitGeometry = createGeometryFromPositionsExtruded(
+        ellipsoid,
+        polygons[i],
+        hasTextureCoordinates ? textureCoordinatePolygons[i] : void 0,
+        granularity,
+        hierarchy[i],
+        perPositionHeight,
+        closeTop,
+        closeBottom,
+        vertexFormat,
+        arcType
+      );
+      let topAndBottom;
+      if (closeTop && closeBottom) {
+        topAndBottom = splitGeometry.topAndBottom;
+        options.geometry = PolygonGeometryLibrary_default.scaleToGeodeticHeightExtruded(
+          topAndBottom.geometry,
+          height,
+          extrudedHeight,
+          ellipsoid,
+          perPositionHeight
+        );
+      } else if (closeTop) {
+        topAndBottom = splitGeometry.topAndBottom;
+        topAndBottom.geometry.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
+          topAndBottom.geometry.attributes.position.values,
+          height,
+          ellipsoid,
+          !perPositionHeight
+        );
+        options.geometry = topAndBottom.geometry;
+      } else if (closeBottom) {
+        topAndBottom = splitGeometry.topAndBottom;
+        topAndBottom.geometry.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
+          topAndBottom.geometry.attributes.position.values,
+          extrudedHeight,
+          ellipsoid,
+          true
+        );
+        options.geometry = topAndBottom.geometry;
+      }
+      if (closeTop || closeBottom) {
+        options.wall = false;
+        topAndBottom.geometry = computeAttributes(options);
+        geometries.push(topAndBottom);
+      }
+      const walls = splitGeometry.walls;
+      options.wall = true;
+      for (let k = 0; k < walls.length; k++) {
+        const wall = walls[k];
+        options.geometry = PolygonGeometryLibrary_default.scaleToGeodeticHeightExtruded(
+          wall.geometry,
+          height,
+          extrudedHeight,
+          ellipsoid,
+          perPositionHeight
+        );
+        wall.geometry = computeAttributes(options);
+        geometries.push(wall);
+      }
+    }
+  } else {
+    for (i = 0; i < polygons.length; i++) {
+      const geometryInstance = new GeometryInstance_default({
+        geometry: PolygonGeometryLibrary_default.createGeometryFromPositions(
+          ellipsoid,
+          polygons[i],
+          hasTextureCoordinates ? textureCoordinatePolygons[i] : void 0,
+          granularity,
+          perPositionHeight,
+          vertexFormat,
+          arcType
+        )
+      });
+      geometryInstance.geometry.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
+        geometryInstance.geometry.attributes.position.values,
+        height,
+        ellipsoid,
+        !perPositionHeight
+      );
+      options.geometry = geometryInstance.geometry;
+      geometryInstance.geometry = computeAttributes(options);
+      if (defined_default(polygonGeometry._offsetAttribute)) {
+        const length = geometryInstance.geometry.attributes.position.values.length;
+        const offsetValue = polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+        const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
+        geometryInstance.geometry.attributes.applyOffset = new GeometryAttribute_default(
+          {
+            componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+            componentsPerAttribute: 1,
+            values: applyOffset
+          }
+        );
+      }
+      geometries.push(geometryInstance);
+    }
+  }
+  const geometry = GeometryPipeline_default.combineInstances(geometries)[0];
+  geometry.attributes.position.values = new Float64Array(
+    geometry.attributes.position.values
+  );
+  geometry.indices = IndexDatatype_default.createTypedArray(
+    geometry.attributes.position.values.length / 3,
+    geometry.indices
+  );
+  const attributes = geometry.attributes;
+  const boundingSphere = BoundingSphere_default.fromVertices(
+    attributes.position.values
+  );
+  if (!vertexFormat.position) {
+    delete attributes.position;
+  }
+  return new Geometry_default({
+    attributes,
+    indices: geometry.indices,
+    primitiveType: geometry.primitiveType,
+    boundingSphere,
+    offsetAttribute: polygonGeometry._offsetAttribute
+  });
+};
+PolygonGeometry.createShadowVolume = function(polygonGeometry, minHeightFunc, maxHeightFunc) {
+  const granularity = polygonGeometry._granularity;
+  const ellipsoid = polygonGeometry._ellipsoid;
+  const minHeight = minHeightFunc(granularity, ellipsoid);
+  const maxHeight = maxHeightFunc(granularity, ellipsoid);
+  return new PolygonGeometry({
+    polygonHierarchy: polygonGeometry._polygonHierarchy,
+    ellipsoid,
+    stRotation: polygonGeometry._stRotation,
+    granularity,
+    perPositionHeight: false,
+    extrudedHeight: minHeight,
+    height: maxHeight,
+    vertexFormat: VertexFormat_default.POSITION_ONLY,
+    shadowVolume: true,
+    arcType: polygonGeometry._arcType
+  });
+};
+function textureCoordinateRotationPoints(polygonGeometry) {
+  const stRotation = -polygonGeometry._stRotation;
+  if (stRotation === 0) {
+    return [0, 0, 0, 1, 1, 0];
+  }
+  const ellipsoid = polygonGeometry._ellipsoid;
+  const positions = polygonGeometry._polygonHierarchy.positions;
+  const boundingRectangle = polygonGeometry.rectangle;
+  return Geometry_default._textureCoordinateRotationPoints(
+    positions,
+    stRotation,
+    ellipsoid,
+    boundingRectangle
+  );
+}
+Object.defineProperties(PolygonGeometry.prototype, {
+  /**
+   * @private
+   */
+  rectangle: {
+    get: function() {
+      if (!defined_default(this._rectangle)) {
+        const positions = this._polygonHierarchy.positions;
+        this._rectangle = PolygonGeometry.computeRectangleFromPositions(
+          positions,
+          this._ellipsoid,
+          this._arcType
+        );
+      }
+      return this._rectangle;
+    }
+  },
+  /**
+   * For remapping texture coordinates when rendering PolygonGeometries as GroundPrimitives.
+   * @private
+   */
+  textureCoordinateRotationPoints: {
+    get: function() {
+      if (!defined_default(this._textureCoordinateRotationPoints)) {
+        this._textureCoordinateRotationPoints = textureCoordinateRotationPoints(
+          this
+        );
+      }
+      return this._textureCoordinateRotationPoints;
+    }
+  }
+});
+var PolygonGeometry_default = PolygonGeometry;
+
+// packages/engine/Source/Workers/createPolygonGeometry.js
+function createPolygonGeometry(polygonGeometry, offset) {
+  if (defined_default(offset)) {
+    polygonGeometry = PolygonGeometry_default.unpack(polygonGeometry, offset);
+  }
+  polygonGeometry._ellipsoid = Ellipsoid_default.clone(polygonGeometry._ellipsoid);
+  return PolygonGeometry_default.createGeometry(polygonGeometry);
+}
+var createPolygonGeometry_default = createPolygonGeometry;
+export {
+  createPolygonGeometry_default as default
+};

public/assets/cesium/Workers/createPolygonOutlineGeometry.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 {
+  PolygonGeometryLibrary_default
+} from "./chunk-IZJ42N4W.js";
+import {
+  ArcType_default
+} from "./chunk-XWOUPGUF.js";
+import {
+  GeometryInstance_default
+} from "./chunk-YSIJTJ7N.js";
+import {
+  GeometryPipeline_default
+} from "./chunk-7ZZ5LMZY.js";
+import "./chunk-LJ2JQHJT.js";
+import "./chunk-NGZJIN5Z.js";
+import {
+  GeometryOffsetAttribute_default
+} from "./chunk-GBT7MJ6X.js";
+import {
+  EllipsoidTangentPlane_default
+} from "./chunk-YK3QIKY7.js";
+import "./chunk-NDDI2LWR.js";
+import {
+  PolygonPipeline_default,
+  WindingOrder_default
+} from "./chunk-TI3TRKIC.js";
+import "./chunk-57H6I3SV.js";
+import "./chunk-JSQJDZI4.js";
+import "./chunk-QQOZO7KO.js";
+import "./chunk-EDLRS3AW.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 "./chunk-6SQMLVGV.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 "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.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/PolygonOutlineGeometry.js
+var createGeometryFromPositionsPositions = [];
+var createGeometryFromPositionsSubdivided = [];
+function createGeometryFromPositions(ellipsoid, positions, minDistance, perPositionHeight, arcType) {
+  const tangentPlane = EllipsoidTangentPlane_default.fromPoints(positions, ellipsoid);
+  const positions2D = tangentPlane.projectPointsOntoPlane(
+    positions,
+    createGeometryFromPositionsPositions
+  );
+  const originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(
+    positions2D
+  );
+  if (originalWindingOrder === WindingOrder_default.CLOCKWISE) {
+    positions2D.reverse();
+    positions = positions.slice().reverse();
+  }
+  let subdividedPositions;
+  let i;
+  let length = positions.length;
+  let index = 0;
+  if (!perPositionHeight) {
+    let numVertices = 0;
+    if (arcType === ArcType_default.GEODESIC) {
+      for (i = 0; i < length; i++) {
+        numVertices += PolygonGeometryLibrary_default.subdivideLineCount(
+          positions[i],
+          positions[(i + 1) % length],
+          minDistance
+        );
+      }
+    } else if (arcType === ArcType_default.RHUMB) {
+      for (i = 0; i < length; i++) {
+        numVertices += PolygonGeometryLibrary_default.subdivideRhumbLineCount(
+          ellipsoid,
+          positions[i],
+          positions[(i + 1) % length],
+          minDistance
+        );
+      }
+    }
+    subdividedPositions = new Float64Array(numVertices * 3);
+    for (i = 0; i < length; i++) {
+      let tempPositions;
+      if (arcType === ArcType_default.GEODESIC) {
+        tempPositions = PolygonGeometryLibrary_default.subdivideLine(
+          positions[i],
+          positions[(i + 1) % length],
+          minDistance,
+          createGeometryFromPositionsSubdivided
+        );
+      } else if (arcType === ArcType_default.RHUMB) {
+        tempPositions = PolygonGeometryLibrary_default.subdivideRhumbLine(
+          ellipsoid,
+          positions[i],
+          positions[(i + 1) % length],
+          minDistance,
+          createGeometryFromPositionsSubdivided
+        );
+      }
+      const tempPositionsLength = tempPositions.length;
+      for (let j = 0; j < tempPositionsLength; ++j) {
+        subdividedPositions[index++] = tempPositions[j];
+      }
+    }
+  } else {
+    subdividedPositions = new Float64Array(length * 2 * 3);
+    for (i = 0; i < length; i++) {
+      const p0 = positions[i];
+      const p1 = positions[(i + 1) % length];
+      subdividedPositions[index++] = p0.x;
+      subdividedPositions[index++] = p0.y;
+      subdividedPositions[index++] = p0.z;
+      subdividedPositions[index++] = p1.x;
+      subdividedPositions[index++] = p1.y;
+      subdividedPositions[index++] = p1.z;
+    }
+  }
+  length = subdividedPositions.length / 3;
+  const indicesSize = length * 2;
+  const indices = IndexDatatype_default.createTypedArray(length, indicesSize);
+  index = 0;
+  for (i = 0; i < length - 1; i++) {
+    indices[index++] = i;
+    indices[index++] = i + 1;
+  }
+  indices[index++] = length - 1;
+  indices[index++] = 0;
+  return new GeometryInstance_default({
+    geometry: new Geometry_default({
+      attributes: new GeometryAttributes_default({
+        position: new GeometryAttribute_default({
+          componentDatatype: ComponentDatatype_default.DOUBLE,
+          componentsPerAttribute: 3,
+          values: subdividedPositions
+        })
+      }),
+      indices,
+      primitiveType: PrimitiveType_default.LINES
+    })
+  });
+}
+function createGeometryFromPositionsExtruded(ellipsoid, positions, minDistance, perPositionHeight, arcType) {
+  const tangentPlane = EllipsoidTangentPlane_default.fromPoints(positions, ellipsoid);
+  const positions2D = tangentPlane.projectPointsOntoPlane(
+    positions,
+    createGeometryFromPositionsPositions
+  );
+  const originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(
+    positions2D
+  );
+  if (originalWindingOrder === WindingOrder_default.CLOCKWISE) {
+    positions2D.reverse();
+    positions = positions.slice().reverse();
+  }
+  let subdividedPositions;
+  let i;
+  let length = positions.length;
+  const corners = new Array(length);
+  let index = 0;
+  if (!perPositionHeight) {
+    let numVertices = 0;
+    if (arcType === ArcType_default.GEODESIC) {
+      for (i = 0; i < length; i++) {
+        numVertices += PolygonGeometryLibrary_default.subdivideLineCount(
+          positions[i],
+          positions[(i + 1) % length],
+          minDistance
+        );
+      }
+    } else if (arcType === ArcType_default.RHUMB) {
+      for (i = 0; i < length; i++) {
+        numVertices += PolygonGeometryLibrary_default.subdivideRhumbLineCount(
+          ellipsoid,
+          positions[i],
+          positions[(i + 1) % length],
+          minDistance
+        );
+      }
+    }
+    subdividedPositions = new Float64Array(numVertices * 3 * 2);
+    for (i = 0; i < length; ++i) {
+      corners[i] = index / 3;
+      let tempPositions;
+      if (arcType === ArcType_default.GEODESIC) {
+        tempPositions = PolygonGeometryLibrary_default.subdivideLine(
+          positions[i],
+          positions[(i + 1) % length],
+          minDistance,
+          createGeometryFromPositionsSubdivided
+        );
+      } else if (arcType === ArcType_default.RHUMB) {
+        tempPositions = PolygonGeometryLibrary_default.subdivideRhumbLine(
+          ellipsoid,
+          positions[i],
+          positions[(i + 1) % length],
+          minDistance,
+          createGeometryFromPositionsSubdivided
+        );
+      }
+      const tempPositionsLength = tempPositions.length;
+      for (let j = 0; j < tempPositionsLength; ++j) {
+        subdividedPositions[index++] = tempPositions[j];
+      }
+    }
+  } else {
+    subdividedPositions = new Float64Array(length * 2 * 3 * 2);
+    for (i = 0; i < length; ++i) {
+      corners[i] = index / 3;
+      const p0 = positions[i];
+      const p1 = positions[(i + 1) % length];
+      subdividedPositions[index++] = p0.x;
+      subdividedPositions[index++] = p0.y;
+      subdividedPositions[index++] = p0.z;
+      subdividedPositions[index++] = p1.x;
+      subdividedPositions[index++] = p1.y;
+      subdividedPositions[index++] = p1.z;
+    }
+  }
+  length = subdividedPositions.length / (3 * 2);
+  const cornersLength = corners.length;
+  const indicesSize = (length * 2 + cornersLength) * 2;
+  const indices = IndexDatatype_default.createTypedArray(
+    length + cornersLength,
+    indicesSize
+  );
+  index = 0;
+  for (i = 0; i < length; ++i) {
+    indices[index++] = i;
+    indices[index++] = (i + 1) % length;
+    indices[index++] = i + length;
+    indices[index++] = (i + 1) % length + length;
+  }
+  for (i = 0; i < cornersLength; i++) {
+    const corner = corners[i];
+    indices[index++] = corner;
+    indices[index++] = corner + length;
+  }
+  return new GeometryInstance_default({
+    geometry: new Geometry_default({
+      attributes: new GeometryAttributes_default({
+        position: new GeometryAttribute_default({
+          componentDatatype: ComponentDatatype_default.DOUBLE,
+          componentsPerAttribute: 3,
+          values: subdividedPositions
+        })
+      }),
+      indices,
+      primitiveType: PrimitiveType_default.LINES
+    })
+  });
+}
+function PolygonOutlineGeometry(options) {
+  Check_default.typeOf.object("options", options);
+  Check_default.typeOf.object("options.polygonHierarchy", options.polygonHierarchy);
+  if (options.perPositionHeight && defined_default(options.height)) {
+    throw new DeveloperError_default(
+      "Cannot use both options.perPositionHeight and options.height"
+    );
+  }
+  if (defined_default(options.arcType) && options.arcType !== ArcType_default.GEODESIC && options.arcType !== ArcType_default.RHUMB) {
+    throw new DeveloperError_default(
+      "Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB."
+    );
+  }
+  const polygonHierarchy = options.polygonHierarchy;
+  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.default);
+  const granularity = defaultValue_default(
+    options.granularity,
+    Math_default.RADIANS_PER_DEGREE
+  );
+  const perPositionHeight = defaultValue_default(options.perPositionHeight, false);
+  const perPositionHeightExtrude = perPositionHeight && defined_default(options.extrudedHeight);
+  const arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
+  let height = defaultValue_default(options.height, 0);
+  let extrudedHeight = defaultValue_default(options.extrudedHeight, height);
+  if (!perPositionHeightExtrude) {
+    const h = Math.max(height, extrudedHeight);
+    extrudedHeight = Math.min(height, extrudedHeight);
+    height = h;
+  }
+  this._ellipsoid = Ellipsoid_default.clone(ellipsoid);
+  this._granularity = granularity;
+  this._height = height;
+  this._extrudedHeight = extrudedHeight;
+  this._arcType = arcType;
+  this._polygonHierarchy = polygonHierarchy;
+  this._perPositionHeight = perPositionHeight;
+  this._perPositionHeightExtrude = perPositionHeightExtrude;
+  this._offsetAttribute = options.offsetAttribute;
+  this._workerName = "createPolygonOutlineGeometry";
+  this.packedLength = PolygonGeometryLibrary_default.computeHierarchyPackedLength(
+    polygonHierarchy,
+    Cartesian3_default
+  ) + Ellipsoid_default.packedLength + 8;
+}
+PolygonOutlineGeometry.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  startingIndex = PolygonGeometryLibrary_default.packPolygonHierarchy(
+    value._polygonHierarchy,
+    array,
+    startingIndex,
+    Cartesian3_default
+  );
+  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
+  startingIndex += Ellipsoid_default.packedLength;
+  array[startingIndex++] = value._height;
+  array[startingIndex++] = value._extrudedHeight;
+  array[startingIndex++] = value._granularity;
+  array[startingIndex++] = value._perPositionHeightExtrude ? 1 : 0;
+  array[startingIndex++] = value._perPositionHeight ? 1 : 0;
+  array[startingIndex++] = value._arcType;
+  array[startingIndex++] = defaultValue_default(value._offsetAttribute, -1);
+  array[startingIndex] = value.packedLength;
+  return array;
+};
+var scratchEllipsoid = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
+var dummyOptions = {
+  polygonHierarchy: {}
+};
+PolygonOutlineGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const polygonHierarchy = PolygonGeometryLibrary_default.unpackPolygonHierarchy(
+    array,
+    startingIndex,
+    Cartesian3_default
+  );
+  startingIndex = polygonHierarchy.startingIndex;
+  delete polygonHierarchy.startingIndex;
+  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
+  startingIndex += Ellipsoid_default.packedLength;
+  const height = array[startingIndex++];
+  const extrudedHeight = array[startingIndex++];
+  const granularity = array[startingIndex++];
+  const perPositionHeightExtrude = array[startingIndex++] === 1;
+  const perPositionHeight = array[startingIndex++] === 1;
+  const arcType = array[startingIndex++];
+  const offsetAttribute = array[startingIndex++];
+  const packedLength = array[startingIndex];
+  if (!defined_default(result)) {
+    result = new PolygonOutlineGeometry(dummyOptions);
+  }
+  result._polygonHierarchy = polygonHierarchy;
+  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
+  result._height = height;
+  result._extrudedHeight = extrudedHeight;
+  result._granularity = granularity;
+  result._perPositionHeight = perPositionHeight;
+  result._perPositionHeightExtrude = perPositionHeightExtrude;
+  result._arcType = arcType;
+  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+  result.packedLength = packedLength;
+  return result;
+};
+PolygonOutlineGeometry.fromPositions = function(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  Check_default.defined("options.positions", options.positions);
+  const newOptions = {
+    polygonHierarchy: {
+      positions: options.positions
+    },
+    height: options.height,
+    extrudedHeight: options.extrudedHeight,
+    ellipsoid: options.ellipsoid,
+    granularity: options.granularity,
+    perPositionHeight: options.perPositionHeight,
+    arcType: options.arcType,
+    offsetAttribute: options.offsetAttribute
+  };
+  return new PolygonOutlineGeometry(newOptions);
+};
+PolygonOutlineGeometry.createGeometry = function(polygonGeometry) {
+  const ellipsoid = polygonGeometry._ellipsoid;
+  const granularity = polygonGeometry._granularity;
+  const polygonHierarchy = polygonGeometry._polygonHierarchy;
+  const perPositionHeight = polygonGeometry._perPositionHeight;
+  const arcType = polygonGeometry._arcType;
+  const polygons = PolygonGeometryLibrary_default.polygonOutlinesFromHierarchy(
+    polygonHierarchy,
+    !perPositionHeight,
+    ellipsoid
+  );
+  if (polygons.length === 0) {
+    return void 0;
+  }
+  let geometryInstance;
+  const geometries = [];
+  const minDistance = Math_default.chordLength(
+    granularity,
+    ellipsoid.maximumRadius
+  );
+  const height = polygonGeometry._height;
+  const extrudedHeight = polygonGeometry._extrudedHeight;
+  const extrude = polygonGeometry._perPositionHeightExtrude || !Math_default.equalsEpsilon(height, extrudedHeight, 0, Math_default.EPSILON2);
+  let offsetValue;
+  let i;
+  if (extrude) {
+    for (i = 0; i < polygons.length; i++) {
+      geometryInstance = createGeometryFromPositionsExtruded(
+        ellipsoid,
+        polygons[i],
+        minDistance,
+        perPositionHeight,
+        arcType
+      );
+      geometryInstance.geometry = PolygonGeometryLibrary_default.scaleToGeodeticHeightExtruded(
+        geometryInstance.geometry,
+        height,
+        extrudedHeight,
+        ellipsoid,
+        perPositionHeight
+      );
+      if (defined_default(polygonGeometry._offsetAttribute)) {
+        const size = geometryInstance.geometry.attributes.position.values.length / 3;
+        let offsetAttribute = new Uint8Array(size);
+        if (polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.TOP) {
+          offsetAttribute = offsetAttribute.fill(1, 0, size / 2);
+        } else {
+          offsetValue = polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+          offsetAttribute = offsetAttribute.fill(offsetValue);
+        }
+        geometryInstance.geometry.attributes.applyOffset = new GeometryAttribute_default(
+          {
+            componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+            componentsPerAttribute: 1,
+            values: offsetAttribute
+          }
+        );
+      }
+      geometries.push(geometryInstance);
+    }
+  } else {
+    for (i = 0; i < polygons.length; i++) {
+      geometryInstance = createGeometryFromPositions(
+        ellipsoid,
+        polygons[i],
+        minDistance,
+        perPositionHeight,
+        arcType
+      );
+      geometryInstance.geometry.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
+        geometryInstance.geometry.attributes.position.values,
+        height,
+        ellipsoid,
+        !perPositionHeight
+      );
+      if (defined_default(polygonGeometry._offsetAttribute)) {
+        const length = geometryInstance.geometry.attributes.position.values.length;
+        offsetValue = polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+        const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
+        geometryInstance.geometry.attributes.applyOffset = new GeometryAttribute_default(
+          {
+            componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+            componentsPerAttribute: 1,
+            values: applyOffset
+          }
+        );
+      }
+      geometries.push(geometryInstance);
+    }
+  }
+  const geometry = GeometryPipeline_default.combineInstances(geometries)[0];
+  const boundingSphere = BoundingSphere_default.fromVertices(
+    geometry.attributes.position.values
+  );
+  return new Geometry_default({
+    attributes: geometry.attributes,
+    indices: geometry.indices,
+    primitiveType: geometry.primitiveType,
+    boundingSphere,
+    offsetAttribute: polygonGeometry._offsetAttribute
+  });
+};
+var PolygonOutlineGeometry_default = PolygonOutlineGeometry;
+
+// packages/engine/Source/Workers/createPolygonOutlineGeometry.js
+function createPolygonOutlineGeometry(polygonGeometry, offset) {
+  if (defined_default(offset)) {
+    polygonGeometry = PolygonOutlineGeometry_default.unpack(polygonGeometry, offset);
+  }
+  polygonGeometry._ellipsoid = Ellipsoid_default.clone(polygonGeometry._ellipsoid);
+  return PolygonOutlineGeometry_default.createGeometry(polygonGeometry);
+}
+var createPolygonOutlineGeometry_default = createPolygonOutlineGeometry;
+export {
+  createPolygonOutlineGeometry_default as default
+};

public/assets/cesium/Workers/createPolylineGeometry.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 {
+  Color_default
+} from "./chunk-HP5XLODI.js";
+import {
+  ArcType_default
+} from "./chunk-XWOUPGUF.js";
+import {
+  PolylinePipeline_default
+} from "./chunk-QN6TBED4.js";
+import "./chunk-C3EQ27WF.js";
+import {
+  VertexFormat_default
+} from "./chunk-JBSKHTNX.js";
+import {
+  arrayRemoveDuplicates_default
+} from "./chunk-57H6I3SV.js";
+import "./chunk-JSQJDZI4.js";
+import "./chunk-QQOZO7KO.js";
+import "./chunk-EDLRS3AW.js";
+import {
+  IndexDatatype_default
+} from "./chunk-C4WPMOKT.js";
+import {
+  GeometryAttributes_default
+} from "./chunk-X7IQYYHF.js";
+import {
+  GeometryAttribute_default,
+  GeometryType_default,
+  Geometry_default,
+  PrimitiveType_default
+} from "./chunk-JXVLNVXC.js";
+import {
+  BoundingSphere_default
+} from "./chunk-KHZNBFOH.js";
+import "./chunk-6SQMLVGV.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 "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.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/PolylineGeometry.js
+var scratchInterpolateColorsArray = [];
+function interpolateColors(p0, p1, color0, color1, numPoints) {
+  const colors = scratchInterpolateColorsArray;
+  colors.length = numPoints;
+  let i;
+  const r0 = color0.red;
+  const g0 = color0.green;
+  const b0 = color0.blue;
+  const a0 = color0.alpha;
+  const r1 = color1.red;
+  const g1 = color1.green;
+  const b1 = color1.blue;
+  const a1 = color1.alpha;
+  if (Color_default.equals(color0, color1)) {
+    for (i = 0; i < numPoints; i++) {
+      colors[i] = Color_default.clone(color0);
+    }
+    return colors;
+  }
+  const redPerVertex = (r1 - r0) / numPoints;
+  const greenPerVertex = (g1 - g0) / numPoints;
+  const bluePerVertex = (b1 - b0) / numPoints;
+  const alphaPerVertex = (a1 - a0) / numPoints;
+  for (i = 0; i < numPoints; i++) {
+    colors[i] = new Color_default(
+      r0 + i * redPerVertex,
+      g0 + i * greenPerVertex,
+      b0 + i * bluePerVertex,
+      a0 + i * alphaPerVertex
+    );
+  }
+  return colors;
+}
+function PolylineGeometry(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const positions = options.positions;
+  const colors = options.colors;
+  const width = defaultValue_default(options.width, 1);
+  const colorsPerVertex = defaultValue_default(options.colorsPerVertex, false);
+  if (!defined_default(positions) || positions.length < 2) {
+    throw new DeveloperError_default("At least two positions are required.");
+  }
+  if (typeof width !== "number") {
+    throw new DeveloperError_default("width must be a number");
+  }
+  if (defined_default(colors) && (colorsPerVertex && colors.length < positions.length || !colorsPerVertex && colors.length < positions.length - 1)) {
+    throw new DeveloperError_default("colors has an invalid length.");
+  }
+  this._positions = positions;
+  this._colors = colors;
+  this._width = width;
+  this._colorsPerVertex = colorsPerVertex;
+  this._vertexFormat = VertexFormat_default.clone(
+    defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT)
+  );
+  this._arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
+  this._granularity = defaultValue_default(
+    options.granularity,
+    Math_default.RADIANS_PER_DEGREE
+  );
+  this._ellipsoid = Ellipsoid_default.clone(
+    defaultValue_default(options.ellipsoid, Ellipsoid_default.default)
+  );
+  this._workerName = "createPolylineGeometry";
+  let numComponents = 1 + positions.length * Cartesian3_default.packedLength;
+  numComponents += defined_default(colors) ? 1 + colors.length * Color_default.packedLength : 1;
+  this.packedLength = numComponents + Ellipsoid_default.packedLength + VertexFormat_default.packedLength + 4;
+}
+PolylineGeometry.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);
+  let i;
+  const positions = value._positions;
+  let length = positions.length;
+  array[startingIndex++] = length;
+  for (i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
+    Cartesian3_default.pack(positions[i], array, startingIndex);
+  }
+  const colors = value._colors;
+  length = defined_default(colors) ? colors.length : 0;
+  array[startingIndex++] = length;
+  for (i = 0; i < length; ++i, startingIndex += Color_default.packedLength) {
+    Color_default.pack(colors[i], array, startingIndex);
+  }
+  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
+  startingIndex += Ellipsoid_default.packedLength;
+  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
+  startingIndex += VertexFormat_default.packedLength;
+  array[startingIndex++] = value._width;
+  array[startingIndex++] = value._colorsPerVertex ? 1 : 0;
+  array[startingIndex++] = value._arcType;
+  array[startingIndex] = value._granularity;
+  return array;
+};
+var scratchEllipsoid = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
+var scratchVertexFormat = new VertexFormat_default();
+var scratchOptions = {
+  positions: void 0,
+  colors: void 0,
+  ellipsoid: scratchEllipsoid,
+  vertexFormat: scratchVertexFormat,
+  width: void 0,
+  colorsPerVertex: void 0,
+  arcType: void 0,
+  granularity: void 0
+};
+PolylineGeometry.unpack = function(array, startingIndex, result) {
+  if (!defined_default(array)) {
+    throw new DeveloperError_default("array is required");
+  }
+  startingIndex = defaultValue_default(startingIndex, 0);
+  let i;
+  let length = array[startingIndex++];
+  const positions = new Array(length);
+  for (i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
+    positions[i] = Cartesian3_default.unpack(array, startingIndex);
+  }
+  length = array[startingIndex++];
+  const colors = length > 0 ? new Array(length) : void 0;
+  for (i = 0; i < length; ++i, startingIndex += Color_default.packedLength) {
+    colors[i] = Color_default.unpack(array, startingIndex);
+  }
+  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
+  startingIndex += Ellipsoid_default.packedLength;
+  const vertexFormat = VertexFormat_default.unpack(
+    array,
+    startingIndex,
+    scratchVertexFormat
+  );
+  startingIndex += VertexFormat_default.packedLength;
+  const width = array[startingIndex++];
+  const colorsPerVertex = array[startingIndex++] === 1;
+  const arcType = array[startingIndex++];
+  const granularity = array[startingIndex];
+  if (!defined_default(result)) {
+    scratchOptions.positions = positions;
+    scratchOptions.colors = colors;
+    scratchOptions.width = width;
+    scratchOptions.colorsPerVertex = colorsPerVertex;
+    scratchOptions.arcType = arcType;
+    scratchOptions.granularity = granularity;
+    return new PolylineGeometry(scratchOptions);
+  }
+  result._positions = positions;
+  result._colors = colors;
+  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
+  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
+  result._width = width;
+  result._colorsPerVertex = colorsPerVertex;
+  result._arcType = arcType;
+  result._granularity = granularity;
+  return result;
+};
+var scratchCartesian3 = new Cartesian3_default();
+var scratchPosition = new Cartesian3_default();
+var scratchPrevPosition = new Cartesian3_default();
+var scratchNextPosition = new Cartesian3_default();
+PolylineGeometry.createGeometry = function(polylineGeometry) {
+  const width = polylineGeometry._width;
+  const vertexFormat = polylineGeometry._vertexFormat;
+  let colors = polylineGeometry._colors;
+  const colorsPerVertex = polylineGeometry._colorsPerVertex;
+  const arcType = polylineGeometry._arcType;
+  const granularity = polylineGeometry._granularity;
+  const ellipsoid = polylineGeometry._ellipsoid;
+  let i;
+  let j;
+  let k;
+  const removedIndices = [];
+  let positions = arrayRemoveDuplicates_default(
+    polylineGeometry._positions,
+    Cartesian3_default.equalsEpsilon,
+    false,
+    removedIndices
+  );
+  if (defined_default(colors) && removedIndices.length > 0) {
+    let removedArrayIndex = 0;
+    let nextRemovedIndex = removedIndices[0];
+    colors = colors.filter(function(color, index2) {
+      let remove = false;
+      if (colorsPerVertex) {
+        remove = index2 === nextRemovedIndex || index2 === 0 && nextRemovedIndex === 1;
+      } else {
+        remove = index2 + 1 === nextRemovedIndex;
+      }
+      if (remove) {
+        removedArrayIndex++;
+        nextRemovedIndex = removedIndices[removedArrayIndex];
+        return false;
+      }
+      return true;
+    });
+  }
+  let positionsLength = positions.length;
+  if (positionsLength < 2 || width <= 0) {
+    return void 0;
+  }
+  if (arcType === ArcType_default.GEODESIC || arcType === ArcType_default.RHUMB) {
+    let subdivisionSize;
+    let numberOfPointsFunction;
+    if (arcType === ArcType_default.GEODESIC) {
+      subdivisionSize = Math_default.chordLength(
+        granularity,
+        ellipsoid.maximumRadius
+      );
+      numberOfPointsFunction = PolylinePipeline_default.numberOfPoints;
+    } else {
+      subdivisionSize = granularity;
+      numberOfPointsFunction = PolylinePipeline_default.numberOfPointsRhumbLine;
+    }
+    const heights = PolylinePipeline_default.extractHeights(positions, ellipsoid);
+    if (defined_default(colors)) {
+      let colorLength = 1;
+      for (i = 0; i < positionsLength - 1; ++i) {
+        colorLength += numberOfPointsFunction(
+          positions[i],
+          positions[i + 1],
+          subdivisionSize
+        );
+      }
+      const newColors = new Array(colorLength);
+      let newColorIndex = 0;
+      for (i = 0; i < positionsLength - 1; ++i) {
+        const p0 = positions[i];
+        const p1 = positions[i + 1];
+        const c0 = colors[i];
+        const numColors = numberOfPointsFunction(p0, p1, subdivisionSize);
+        if (colorsPerVertex && i < colorLength) {
+          const c1 = colors[i + 1];
+          const interpolatedColors = interpolateColors(
+            p0,
+            p1,
+            c0,
+            c1,
+            numColors
+          );
+          const interpolatedColorsLength = interpolatedColors.length;
+          for (j = 0; j < interpolatedColorsLength; ++j) {
+            newColors[newColorIndex++] = interpolatedColors[j];
+          }
+        } else {
+          for (j = 0; j < numColors; ++j) {
+            newColors[newColorIndex++] = Color_default.clone(c0);
+          }
+        }
+      }
+      newColors[newColorIndex] = Color_default.clone(colors[colors.length - 1]);
+      colors = newColors;
+      scratchInterpolateColorsArray.length = 0;
+    }
+    if (arcType === ArcType_default.GEODESIC) {
+      positions = PolylinePipeline_default.generateCartesianArc({
+        positions,
+        minDistance: subdivisionSize,
+        ellipsoid,
+        height: heights
+      });
+    } else {
+      positions = PolylinePipeline_default.generateCartesianRhumbArc({
+        positions,
+        granularity: subdivisionSize,
+        ellipsoid,
+        height: heights
+      });
+    }
+  }
+  positionsLength = positions.length;
+  const size = positionsLength * 4 - 4;
+  const finalPositions = new Float64Array(size * 3);
+  const prevPositions = new Float64Array(size * 3);
+  const nextPositions = new Float64Array(size * 3);
+  const expandAndWidth = new Float32Array(size * 2);
+  const st = vertexFormat.st ? new Float32Array(size * 2) : void 0;
+  const finalColors = defined_default(colors) ? new Uint8Array(size * 4) : void 0;
+  let positionIndex = 0;
+  let expandAndWidthIndex = 0;
+  let stIndex = 0;
+  let colorIndex = 0;
+  let position;
+  for (j = 0; j < positionsLength; ++j) {
+    if (j === 0) {
+      position = scratchCartesian3;
+      Cartesian3_default.subtract(positions[0], positions[1], position);
+      Cartesian3_default.add(positions[0], position, position);
+    } else {
+      position = positions[j - 1];
+    }
+    Cartesian3_default.clone(position, scratchPrevPosition);
+    Cartesian3_default.clone(positions[j], scratchPosition);
+    if (j === positionsLength - 1) {
+      position = scratchCartesian3;
+      Cartesian3_default.subtract(
+        positions[positionsLength - 1],
+        positions[positionsLength - 2],
+        position
+      );
+      Cartesian3_default.add(positions[positionsLength - 1], position, position);
+    } else {
+      position = positions[j + 1];
+    }
+    Cartesian3_default.clone(position, scratchNextPosition);
+    let color0, color1;
+    if (defined_default(finalColors)) {
+      if (j !== 0 && !colorsPerVertex) {
+        color0 = colors[j - 1];
+      } else {
+        color0 = colors[j];
+      }
+      if (j !== positionsLength - 1) {
+        color1 = colors[j];
+      }
+    }
+    const startK = j === 0 ? 2 : 0;
+    const endK = j === positionsLength - 1 ? 2 : 4;
+    for (k = startK; k < endK; ++k) {
+      Cartesian3_default.pack(scratchPosition, finalPositions, positionIndex);
+      Cartesian3_default.pack(scratchPrevPosition, prevPositions, positionIndex);
+      Cartesian3_default.pack(scratchNextPosition, nextPositions, positionIndex);
+      positionIndex += 3;
+      const direction = k - 2 < 0 ? -1 : 1;
+      expandAndWidth[expandAndWidthIndex++] = 2 * (k % 2) - 1;
+      expandAndWidth[expandAndWidthIndex++] = direction * width;
+      if (vertexFormat.st) {
+        st[stIndex++] = j / (positionsLength - 1);
+        st[stIndex++] = Math.max(expandAndWidth[expandAndWidthIndex - 2], 0);
+      }
+      if (defined_default(finalColors)) {
+        const color = k < 2 ? color0 : color1;
+        finalColors[colorIndex++] = Color_default.floatToByte(color.red);
+        finalColors[colorIndex++] = Color_default.floatToByte(color.green);
+        finalColors[colorIndex++] = Color_default.floatToByte(color.blue);
+        finalColors[colorIndex++] = Color_default.floatToByte(color.alpha);
+      }
+    }
+  }
+  const attributes = new GeometryAttributes_default();
+  attributes.position = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.DOUBLE,
+    componentsPerAttribute: 3,
+    values: finalPositions
+  });
+  attributes.prevPosition = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.DOUBLE,
+    componentsPerAttribute: 3,
+    values: prevPositions
+  });
+  attributes.nextPosition = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.DOUBLE,
+    componentsPerAttribute: 3,
+    values: nextPositions
+  });
+  attributes.expandAndWidth = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.FLOAT,
+    componentsPerAttribute: 2,
+    values: expandAndWidth
+  });
+  if (vertexFormat.st) {
+    attributes.st = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 2,
+      values: st
+    });
+  }
+  if (defined_default(finalColors)) {
+    attributes.color = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+      componentsPerAttribute: 4,
+      values: finalColors,
+      normalize: true
+    });
+  }
+  const indices = IndexDatatype_default.createTypedArray(size, positionsLength * 6 - 6);
+  let index = 0;
+  let indicesIndex = 0;
+  const length = positionsLength - 1;
+  for (j = 0; j < length; ++j) {
+    indices[indicesIndex++] = index;
+    indices[indicesIndex++] = index + 2;
+    indices[indicesIndex++] = index + 1;
+    indices[indicesIndex++] = index + 1;
+    indices[indicesIndex++] = index + 2;
+    indices[indicesIndex++] = index + 3;
+    index += 4;
+  }
+  return new Geometry_default({
+    attributes,
+    indices,
+    primitiveType: PrimitiveType_default.TRIANGLES,
+    boundingSphere: BoundingSphere_default.fromPoints(positions),
+    geometryType: GeometryType_default.POLYLINES
+  });
+};
+var PolylineGeometry_default = PolylineGeometry;
+
+// packages/engine/Source/Workers/createPolylineGeometry.js
+function createPolylineGeometry(polylineGeometry, offset) {
+  if (defined_default(offset)) {
+    polylineGeometry = PolylineGeometry_default.unpack(polylineGeometry, offset);
+  }
+  polylineGeometry._ellipsoid = Ellipsoid_default.clone(polylineGeometry._ellipsoid);
+  return PolylineGeometry_default.createGeometry(polylineGeometry);
+}
+var createPolylineGeometry_default = createPolylineGeometry;
+export {
+  createPolylineGeometry_default as default
+};

public/assets/cesium/Workers/createPolylineVolumeGeometry.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 {
+  BoundingRectangle_default
+} from "./chunk-44QAAS4P.js";
+import {
+  GeometryPipeline_default
+} from "./chunk-7ZZ5LMZY.js";
+import "./chunk-LJ2JQHJT.js";
+import "./chunk-NGZJIN5Z.js";
+import {
+  CornerType_default,
+  PolylineVolumeGeometryLibrary_default,
+  oneTimeWarning_default
+} from "./chunk-3IFRSGEY.js";
+import "./chunk-QN6TBED4.js";
+import "./chunk-C3EQ27WF.js";
+import {
+  VertexFormat_default
+} from "./chunk-JBSKHTNX.js";
+import "./chunk-YK3QIKY7.js";
+import "./chunk-NDDI2LWR.js";
+import {
+  PolygonPipeline_default,
+  WindingOrder_default
+} from "./chunk-TI3TRKIC.js";
+import {
+  arrayRemoveDuplicates_default
+} from "./chunk-57H6I3SV.js";
+import "./chunk-JSQJDZI4.js";
+import "./chunk-QQOZO7KO.js";
+import "./chunk-EDLRS3AW.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 "./chunk-6SQMLVGV.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-XIUSRWL6.js";
+import {
+  Cartesian2_default,
+  Cartesian3_default,
+  Ellipsoid_default
+} from "./chunk-FFLMY4TE.js";
+import {
+  Math_default
+} from "./chunk-WGDFYAGC.js";
+import "./chunk-3HQMMUPU.js";
+import "./chunk-LLAF3CPH.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/PolylineVolumeGeometry.js
+function computeAttributes(combinedPositions, shape, boundingRectangle, vertexFormat) {
+  const attributes = new GeometryAttributes_default();
+  if (vertexFormat.position) {
+    attributes.position = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.DOUBLE,
+      componentsPerAttribute: 3,
+      values: combinedPositions
+    });
+  }
+  const shapeLength = shape.length;
+  const vertexCount = combinedPositions.length / 3;
+  const length = (vertexCount - shapeLength * 2) / (shapeLength * 2);
+  const firstEndIndices = PolygonPipeline_default.triangulate(shape);
+  const indicesCount = (length - 1) * shapeLength * 6 + firstEndIndices.length * 2;
+  const indices = IndexDatatype_default.createTypedArray(vertexCount, indicesCount);
+  let i, j;
+  let ll, ul, ur, lr;
+  const offset = shapeLength * 2;
+  let index = 0;
+  for (i = 0; i < length - 1; i++) {
+    for (j = 0; j < shapeLength - 1; j++) {
+      ll = j * 2 + i * shapeLength * 2;
+      lr = ll + offset;
+      ul = ll + 1;
+      ur = ul + offset;
+      indices[index++] = ul;
+      indices[index++] = ll;
+      indices[index++] = ur;
+      indices[index++] = ur;
+      indices[index++] = ll;
+      indices[index++] = lr;
+    }
+    ll = shapeLength * 2 - 2 + i * shapeLength * 2;
+    ul = ll + 1;
+    ur = ul + offset;
+    lr = ll + offset;
+    indices[index++] = ul;
+    indices[index++] = ll;
+    indices[index++] = ur;
+    indices[index++] = ur;
+    indices[index++] = ll;
+    indices[index++] = lr;
+  }
+  if (vertexFormat.st || vertexFormat.tangent || vertexFormat.bitangent) {
+    const st = new Float32Array(vertexCount * 2);
+    const lengthSt = 1 / (length - 1);
+    const heightSt = 1 / boundingRectangle.height;
+    const heightOffset = boundingRectangle.height / 2;
+    let s, t;
+    let stindex = 0;
+    for (i = 0; i < length; i++) {
+      s = i * lengthSt;
+      t = heightSt * (shape[0].y + heightOffset);
+      st[stindex++] = s;
+      st[stindex++] = t;
+      for (j = 1; j < shapeLength; j++) {
+        t = heightSt * (shape[j].y + heightOffset);
+        st[stindex++] = s;
+        st[stindex++] = t;
+        st[stindex++] = s;
+        st[stindex++] = t;
+      }
+      t = heightSt * (shape[0].y + heightOffset);
+      st[stindex++] = s;
+      st[stindex++] = t;
+    }
+    for (j = 0; j < shapeLength; j++) {
+      s = 0;
+      t = heightSt * (shape[j].y + heightOffset);
+      st[stindex++] = s;
+      st[stindex++] = t;
+    }
+    for (j = 0; j < shapeLength; j++) {
+      s = (length - 1) * lengthSt;
+      t = heightSt * (shape[j].y + heightOffset);
+      st[stindex++] = s;
+      st[stindex++] = t;
+    }
+    attributes.st = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 2,
+      values: new Float32Array(st)
+    });
+  }
+  const endOffset = vertexCount - shapeLength * 2;
+  for (i = 0; i < firstEndIndices.length; i += 3) {
+    const v0 = firstEndIndices[i] + endOffset;
+    const v1 = firstEndIndices[i + 1] + endOffset;
+    const v2 = firstEndIndices[i + 2] + endOffset;
+    indices[index++] = v0;
+    indices[index++] = v1;
+    indices[index++] = v2;
+    indices[index++] = v2 + shapeLength;
+    indices[index++] = v1 + shapeLength;
+    indices[index++] = v0 + shapeLength;
+  }
+  let geometry = new Geometry_default({
+    attributes,
+    indices,
+    boundingSphere: BoundingSphere_default.fromVertices(combinedPositions),
+    primitiveType: PrimitiveType_default.TRIANGLES
+  });
+  if (vertexFormat.normal) {
+    geometry = GeometryPipeline_default.computeNormal(geometry);
+  }
+  if (vertexFormat.tangent || vertexFormat.bitangent) {
+    try {
+      geometry = GeometryPipeline_default.computeTangentAndBitangent(geometry);
+    } catch (e) {
+      oneTimeWarning_default(
+        "polyline-volume-tangent-bitangent",
+        "Unable to compute tangents and bitangents for polyline volume geometry"
+      );
+    }
+    if (!vertexFormat.tangent) {
+      geometry.attributes.tangent = void 0;
+    }
+    if (!vertexFormat.bitangent) {
+      geometry.attributes.bitangent = void 0;
+    }
+    if (!vertexFormat.st) {
+      geometry.attributes.st = void 0;
+    }
+  }
+  return geometry;
+}
+function PolylineVolumeGeometry(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const positions = options.polylinePositions;
+  const shape = options.shapePositions;
+  if (!defined_default(positions)) {
+    throw new DeveloperError_default("options.polylinePositions is required.");
+  }
+  if (!defined_default(shape)) {
+    throw new DeveloperError_default("options.shapePositions is required.");
+  }
+  this._positions = positions;
+  this._shape = shape;
+  this._ellipsoid = Ellipsoid_default.clone(
+    defaultValue_default(options.ellipsoid, Ellipsoid_default.default)
+  );
+  this._cornerType = defaultValue_default(options.cornerType, CornerType_default.ROUNDED);
+  this._vertexFormat = VertexFormat_default.clone(
+    defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT)
+  );
+  this._granularity = defaultValue_default(
+    options.granularity,
+    Math_default.RADIANS_PER_DEGREE
+  );
+  this._workerName = "createPolylineVolumeGeometry";
+  let numComponents = 1 + positions.length * Cartesian3_default.packedLength;
+  numComponents += 1 + shape.length * Cartesian2_default.packedLength;
+  this.packedLength = numComponents + Ellipsoid_default.packedLength + VertexFormat_default.packedLength + 2;
+}
+PolylineVolumeGeometry.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);
+  let i;
+  const positions = value._positions;
+  let length = positions.length;
+  array[startingIndex++] = length;
+  for (i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
+    Cartesian3_default.pack(positions[i], array, startingIndex);
+  }
+  const shape = value._shape;
+  length = shape.length;
+  array[startingIndex++] = length;
+  for (i = 0; i < length; ++i, startingIndex += Cartesian2_default.packedLength) {
+    Cartesian2_default.pack(shape[i], array, startingIndex);
+  }
+  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
+  startingIndex += Ellipsoid_default.packedLength;
+  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
+  startingIndex += VertexFormat_default.packedLength;
+  array[startingIndex++] = value._cornerType;
+  array[startingIndex] = value._granularity;
+  return array;
+};
+var scratchEllipsoid = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
+var scratchVertexFormat = new VertexFormat_default();
+var scratchOptions = {
+  polylinePositions: void 0,
+  shapePositions: void 0,
+  ellipsoid: scratchEllipsoid,
+  vertexFormat: scratchVertexFormat,
+  cornerType: void 0,
+  granularity: void 0
+};
+PolylineVolumeGeometry.unpack = function(array, startingIndex, result) {
+  if (!defined_default(array)) {
+    throw new DeveloperError_default("array is required");
+  }
+  startingIndex = defaultValue_default(startingIndex, 0);
+  let i;
+  let length = array[startingIndex++];
+  const positions = new Array(length);
+  for (i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
+    positions[i] = Cartesian3_default.unpack(array, startingIndex);
+  }
+  length = array[startingIndex++];
+  const shape = new Array(length);
+  for (i = 0; i < length; ++i, startingIndex += Cartesian2_default.packedLength) {
+    shape[i] = Cartesian2_default.unpack(array, startingIndex);
+  }
+  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
+  startingIndex += Ellipsoid_default.packedLength;
+  const vertexFormat = VertexFormat_default.unpack(
+    array,
+    startingIndex,
+    scratchVertexFormat
+  );
+  startingIndex += VertexFormat_default.packedLength;
+  const cornerType = array[startingIndex++];
+  const granularity = array[startingIndex];
+  if (!defined_default(result)) {
+    scratchOptions.polylinePositions = positions;
+    scratchOptions.shapePositions = shape;
+    scratchOptions.cornerType = cornerType;
+    scratchOptions.granularity = granularity;
+    return new PolylineVolumeGeometry(scratchOptions);
+  }
+  result._positions = positions;
+  result._shape = shape;
+  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
+  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
+  result._cornerType = cornerType;
+  result._granularity = granularity;
+  return result;
+};
+var brScratch = new BoundingRectangle_default();
+PolylineVolumeGeometry.createGeometry = function(polylineVolumeGeometry) {
+  const positions = polylineVolumeGeometry._positions;
+  const cleanPositions = arrayRemoveDuplicates_default(
+    positions,
+    Cartesian3_default.equalsEpsilon
+  );
+  let shape2D = polylineVolumeGeometry._shape;
+  shape2D = PolylineVolumeGeometryLibrary_default.removeDuplicatesFromShape(shape2D);
+  if (cleanPositions.length < 2 || shape2D.length < 3) {
+    return void 0;
+  }
+  if (PolygonPipeline_default.computeWindingOrder2D(shape2D) === WindingOrder_default.CLOCKWISE) {
+    shape2D.reverse();
+  }
+  const boundingRectangle = BoundingRectangle_default.fromPoints(shape2D, brScratch);
+  const computedPositions = PolylineVolumeGeometryLibrary_default.computePositions(
+    cleanPositions,
+    shape2D,
+    boundingRectangle,
+    polylineVolumeGeometry,
+    true
+  );
+  return computeAttributes(
+    computedPositions,
+    shape2D,
+    boundingRectangle,
+    polylineVolumeGeometry._vertexFormat
+  );
+};
+var PolylineVolumeGeometry_default = PolylineVolumeGeometry;
+
+// packages/engine/Source/Workers/createPolylineVolumeGeometry.js
+function createPolylineVolumeGeometry(polylineVolumeGeometry, offset) {
+  if (defined_default(offset)) {
+    polylineVolumeGeometry = PolylineVolumeGeometry_default.unpack(
+      polylineVolumeGeometry,
+      offset
+    );
+  }
+  polylineVolumeGeometry._ellipsoid = Ellipsoid_default.clone(
+    polylineVolumeGeometry._ellipsoid
+  );
+  return PolylineVolumeGeometry_default.createGeometry(polylineVolumeGeometry);
+}
+var createPolylineVolumeGeometry_default = createPolylineVolumeGeometry;
+export {
+  createPolylineVolumeGeometry_default as default
+};