@vcmap/ui 5.0.0-rc.9 → 5.0.1

package/dist/assets/cesium/Workers/createPolygonGeometry.js

@@ -1 +1,1134 @@
-define(["./defaultValue-81eec7ed","./Matrix2-47e98d76","./ArcType-fc72c06c","./GeometryOffsetAttribute-8c5e10db","./BoundingRectangle-c3b79029","./Transforms-c8cb8f43","./RuntimeError-8952249c","./ComponentDatatype-a15c9a19","./EllipsoidGeodesic-19e75e11","./EllipsoidTangentPlane-a01286f6","./GeometryAttribute-89a520b9","./GeometryInstance-4fbf16ba","./GeometryPipeline-309fad76","./IndexDatatype-f1dcdf35","./PolygonGeometryLibrary-0b29eb16","./PolygonPipeline-a934c4dd","./VertexFormat-a0b706b0","./_commonjsHelpers-3aae1032-26891ab7","./combine-3c023bda","./WebGLConstants-508b9636","./AxisAlignedBoundingBox-a655a4bc","./IntersectionTests-58aa8f80","./Plane-3f01019d","./AttributeCompression-80665726","./EncodedCartesian3-d9f5c4a4","./arrayRemoveDuplicates-dc2f4046","./EllipsoidRhumbLine-6145377b","./GeometryAttributes-32b29525"],(function(t,e,o,i,n,r,a,s,l,c,u,p,m,y,g,d,h,f,b,_,P,x,C,w,T,I,A,E){"use strict";const v=new e.Cartographic,G=new e.Cartographic;function O(t,e,o,i){const n=i.cartesianToCartographic(t,v).height,r=i.cartesianToCartographic(e,G);r.height=n,i.cartographicToCartesian(r,e);const a=i.cartesianToCartographic(o,G);a.height=n-100,i.cartographicToCartesian(a,o)}const V=new n.BoundingRectangle,F=new e.Cartesian3,D=new e.Cartesian3,L=new e.Cartesian3,N=new e.Cartesian3,H=new e.Cartesian3,R=new e.Cartesian3;let M=new e.Cartesian3,S=new e.Cartesian3,B=new e.Cartesian3;const k=new e.Cartesian2,z=new e.Cartesian2,W=new e.Cartesian3,Y=new r.Quaternion,U=new e.Matrix3,j=new e.Matrix3;function Q(o){const n=o.vertexFormat,a=o.geometry,l=o.shadowVolume,c=a.attributes.position.values;let p=c.length;const m=o.wall,y=o.top||m,g=o.bottom||m;if(n.st||n.normal||n.tangent||n.bitangent||l){const t=o.boundingRectangle,i=o.tangentPlane,d=o.ellipsoid,h=o.stRotation,f=o.perPositionHeight,b=k;b.x=t.x,b.y=t.y;const _=n.st?new Float32Array(p/3*2):void 0;let P;n.normal&&(P=f&&y&&!m?a.attributes.normal.values:new Float32Array(p));const x=n.tangent?new Float32Array(p):void 0,C=n.bitangent?new Float32Array(p):void 0,w=l?new Float32Array(p):void 0;let T=0,I=0,A=D,E=L,v=N,G=!0,V=U,Q=j;if(0!==h){let t=r.Quaternion.fromAxisAngle(i._plane.normal,h,Y);V=e.Matrix3.fromQuaternion(t,V),t=r.Quaternion.fromAxisAngle(i._plane.normal,-h,Y),Q=e.Matrix3.fromQuaternion(t,Q)}else V=e.Matrix3.clone(e.Matrix3.IDENTITY,V),Q=e.Matrix3.clone(e.Matrix3.IDENTITY,Q);let q=0,K=0;y&&g&&(q=p/2,K=p/3,p/=2);for(let r=0;r<p;r+=3){const a=e.Cartesian3.fromArray(c,r,W);if(n.st){let o=e.Matrix3.multiplyByVector(V,a,F);o=d.scaleToGeodeticSurface(o,o);const n=i.projectPointOntoPlane(o,z);e.Cartesian2.subtract(n,b,n);const r=s.CesiumMath.clamp(n.x/t.width,0,1),l=s.CesiumMath.clamp(n.y/t.height,0,1);g&&(_[T+K]=r,_[T+1+K]=l),y&&(_[T]=r,_[T+1]=l),T+=2}if(n.normal||n.tangent||n.bitangent||l){const t=I+1,i=I+2;if(m){if(r+3<p){const t=e.Cartesian3.fromArray(c,r+3,H);if(G){const o=e.Cartesian3.fromArray(c,r+p,R);f&&O(a,t,o,d),e.Cartesian3.subtract(t,a,t),e.Cartesian3.subtract(o,a,o),A=e.Cartesian3.normalize(e.Cartesian3.cross(o,t,A),A),G=!1}e.Cartesian3.equalsEpsilon(t,a,s.CesiumMath.EPSILON10)&&(G=!0)}(n.tangent||n.bitangent)&&(v=d.geodeticSurfaceNormal(a,v),n.tangent&&(E=e.Cartesian3.normalize(e.Cartesian3.cross(v,A,E),E)))}else A=d.geodeticSurfaceNormal(a,A),(n.tangent||n.bitangent)&&(f&&(M=e.Cartesian3.fromArray(P,I,M),S=e.Cartesian3.cross(e.Cartesian3.UNIT_Z,M,S),S=e.Cartesian3.normalize(e.Matrix3.multiplyByVector(Q,S,S),S),n.bitangent&&(B=e.Cartesian3.normalize(e.Cartesian3.cross(M,S,B),B))),E=e.Cartesian3.cross(e.Cartesian3.UNIT_Z,A,E),E=e.Cartesian3.normalize(e.Matrix3.multiplyByVector(Q,E,E),E),n.bitangent&&(v=e.Cartesian3.normalize(e.Cartesian3.cross(A,E,v),v)));n.normal&&(o.wall?(P[I+q]=A.x,P[t+q]=A.y,P[i+q]=A.z):g&&(P[I+q]=-A.x,P[t+q]=-A.y,P[i+q]=-A.z),(y&&!f||m)&&(P[I]=A.x,P[t]=A.y,P[i]=A.z)),l&&(m&&(A=d.geodeticSurfaceNormal(a,A)),w[I+q]=-A.x,w[t+q]=-A.y,w[i+q]=-A.z),n.tangent&&(o.wall?(x[I+q]=E.x,x[t+q]=E.y,x[i+q]=E.z):g&&(x[I+q]=-E.x,x[t+q]=-E.y,x[i+q]=-E.z),y&&(f?(x[I]=S.x,x[t]=S.y,x[i]=S.z):(x[I]=E.x,x[t]=E.y,x[i]=E.z))),n.bitangent&&(g&&(C[I+q]=v.x,C[t+q]=v.y,C[i+q]=v.z),y&&(f?(C[I]=B.x,C[t]=B.y,C[i]=B.z):(C[I]=v.x,C[t]=v.y,C[i]=v.z))),I+=3}}n.st&&(a.attributes.st=new u.GeometryAttribute({componentDatatype:s.ComponentDatatype.FLOAT,componentsPerAttribute:2,values:_})),n.normal&&(a.attributes.normal=new u.GeometryAttribute({componentDatatype:s.ComponentDatatype.FLOAT,componentsPerAttribute:3,values:P})),n.tangent&&(a.attributes.tangent=new u.GeometryAttribute({componentDatatype:s.ComponentDatatype.FLOAT,componentsPerAttribute:3,values:x})),n.bitangent&&(a.attributes.bitangent=new u.GeometryAttribute({componentDatatype:s.ComponentDatatype.FLOAT,componentsPerAttribute:3,values:C})),l&&(a.attributes.extrudeDirection=new u.GeometryAttribute({componentDatatype:s.ComponentDatatype.FLOAT,componentsPerAttribute:3,values:w}))}if(o.extrude&&t.defined(o.offsetAttribute)){const t=c.length/3;let e=new Uint8Array(t);if(o.offsetAttribute===i.GeometryOffsetAttribute.TOP)y&&g||m?e=i.arrayFill(e,1,0,t/2):y&&(e=i.arrayFill(e,1));else{const t=o.offsetAttribute===i.GeometryOffsetAttribute.NONE?0:1;e=i.arrayFill(e,t)}a.attributes.applyOffset=new u.GeometryAttribute({componentDatatype:s.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:1,values:e})}return a}const q=new e.Cartographic,K=new e.Cartographic,Z={westOverIDL:0,eastOverIDL:0};let J=new l.EllipsoidGeodesic;function X(i,n,r,a,c){if(c=t.defaultValue(c,new e.Rectangle),!t.defined(i)||i.length<3)return c.west=0,c.north=0,c.south=0,c.east=0,c;if(r===o.ArcType.RHUMB)return e.Rectangle.fromCartesianArray(i,n,c);J.ellipsoid.equals(n)||(J=new l.EllipsoidGeodesic(void 0,void 0,n)),c.west=Number.POSITIVE_INFINITY,c.east=Number.NEGATIVE_INFINITY,c.south=Number.POSITIVE_INFINITY,c.north=Number.NEGATIVE_INFINITY,Z.westOverIDL=Number.POSITIVE_INFINITY,Z.eastOverIDL=Number.NEGATIVE_INFINITY;const u=1/s.CesiumMath.chordLength(a,n.maximumRadius),p=i.length;let m,y=n.cartesianToCartographic(i[0],K),g=q;for(let t=1;t<p;t++)m=g,g=y,y=n.cartesianToCartographic(i[t],m),J.setEndPoints(g,y),tt(J,u,c,Z);return m=g,g=y,y=n.cartesianToCartographic(i[0],m),J.setEndPoints(g,y),tt(J,u,c,Z),c.east-c.west>Z.eastOverIDL-Z.westOverIDL&&(c.west=Z.westOverIDL,c.east=Z.eastOverIDL,c.east>s.CesiumMath.PI&&(c.east=c.east-s.CesiumMath.TWO_PI),c.west>s.CesiumMath.PI&&(c.west=c.west-s.CesiumMath.TWO_PI)),c}const $=new e.Cartographic;function tt(t,e,o,i){const n=t.surfaceDistance,r=Math.ceil(n*e),a=r>0?n/(r-1):Number.POSITIVE_INFINITY;let l=0;for(let e=0;e<r;e++){const e=t.interpolateUsingSurfaceDistance(l,$);l+=a;const n=e.longitude,r=e.latitude;o.west=Math.min(o.west,n),o.east=Math.max(o.east,n),o.south=Math.min(o.south,r),o.north=Math.max(o.north,r);const c=n>=0?n:n+s.CesiumMath.TWO_PI;i.westOverIDL=Math.min(i.westOverIDL,c),i.eastOverIDL=Math.max(i.eastOverIDL,c)}}const et=[];function ot(t,e,o,i,n,r,a,s,l){const u={walls:[]};let m;if(r||a){const i=g.PolygonGeometryLibrary.createGeometryFromPositions(t,e,o,n,s,l),c=i.attributes.position.values,d=i.indices;let h,f;if(r&&a){const t=c.concat(c);h=t.length/3,f=y.IndexDatatype.createTypedArray(h,2*d.length),f.set(d);const e=d.length,o=h/2;for(m=0;m<e;m+=3){const t=f[m]+o,i=f[m+1]+o,n=f[m+2]+o;f[m+e]=n,f[m+1+e]=i,f[m+2+e]=t}if(i.attributes.position.values=t,n&&s.normal){const e=i.attributes.normal.values;i.attributes.normal.values=new Float32Array(t.length),i.attributes.normal.values.set(e)}i.indices=f}else if(a){for(h=c.length/3,f=y.IndexDatatype.createTypedArray(h,d.length),m=0;m<d.length;m+=3)f[m]=d[m+2],f[m+1]=d[m+1],f[m+2]=d[m];i.indices=f}u.topAndBottom=new p.GeometryInstance({geometry:i})}let h=i.outerRing,f=c.EllipsoidTangentPlane.fromPoints(h,t),b=f.projectPointsOntoPlane(h,et),_=d.PolygonPipeline.computeWindingOrder2D(b);_===d.WindingOrder.CLOCKWISE&&(h=h.slice().reverse());let P=g.PolygonGeometryLibrary.computeWallGeometry(h,t,o,n,l);u.walls.push(new p.GeometryInstance({geometry:P}));const x=i.holes;for(m=0;m<x.length;m++){let e=x[m];f=c.EllipsoidTangentPlane.fromPoints(e,t),b=f.projectPointsOntoPlane(e,et),_=d.PolygonPipeline.computeWindingOrder2D(b),_===d.WindingOrder.COUNTER_CLOCKWISE&&(e=e.slice().reverse()),P=g.PolygonGeometryLibrary.computeWallGeometry(e,t,o,n,l),u.walls.push(new p.GeometryInstance({geometry:P}))}return u}function it(i){const n=i.polygonHierarchy,r=t.defaultValue(i.vertexFormat,h.VertexFormat.DEFAULT),a=t.defaultValue(i.ellipsoid,e.Ellipsoid.WGS84),l=t.defaultValue(i.granularity,s.CesiumMath.RADIANS_PER_DEGREE),c=t.defaultValue(i.stRotation,0),u=t.defaultValue(i.perPositionHeight,!1),p=u&&t.defined(i.extrudedHeight);let m=t.defaultValue(i.height,0),y=t.defaultValue(i.extrudedHeight,m);if(!p){const t=Math.max(m,y);y=Math.min(m,y),m=t}this._vertexFormat=h.VertexFormat.clone(r),this._ellipsoid=e.Ellipsoid.clone(a),this._granularity=l,this._stRotation=c,this._height=m,this._extrudedHeight=y,this._closeTop=t.defaultValue(i.closeTop,!0),this._closeBottom=t.defaultValue(i.closeBottom,!0),this._polygonHierarchy=n,this._perPositionHeight=u,this._perPositionHeightExtrude=p,this._shadowVolume=t.defaultValue(i.shadowVolume,!1),this._workerName="createPolygonGeometry",this._offsetAttribute=i.offsetAttribute,this._arcType=t.defaultValue(i.arcType,o.ArcType.GEODESIC),this._rectangle=void 0,this._textureCoordinateRotationPoints=void 0,this.packedLength=g.PolygonGeometryLibrary.computeHierarchyPackedLength(n)+e.Ellipsoid.packedLength+h.VertexFormat.packedLength+12}it.fromPositions=function(e){return new it({polygonHierarchy:{positions:(e=t.defaultValue(e,t.defaultValue.EMPTY_OBJECT)).positions},height:e.height,extrudedHeight:e.extrudedHeight,vertexFormat:e.vertexFormat,stRotation:e.stRotation,ellipsoid:e.ellipsoid,granularity:e.granularity,perPositionHeight:e.perPositionHeight,closeTop:e.closeTop,closeBottom:e.closeBottom,offsetAttribute:e.offsetAttribute,arcType:e.arcType})},it.pack=function(o,i,n){return n=t.defaultValue(n,0),n=g.PolygonGeometryLibrary.packPolygonHierarchy(o._polygonHierarchy,i,n),e.Ellipsoid.pack(o._ellipsoid,i,n),n+=e.Ellipsoid.packedLength,h.VertexFormat.pack(o._vertexFormat,i,n),n+=h.VertexFormat.packedLength,i[n++]=o._height,i[n++]=o._extrudedHeight,i[n++]=o._granularity,i[n++]=o._stRotation,i[n++]=o._perPositionHeightExtrude?1:0,i[n++]=o._perPositionHeight?1:0,i[n++]=o._closeTop?1:0,i[n++]=o._closeBottom?1:0,i[n++]=o._shadowVolume?1:0,i[n++]=t.defaultValue(o._offsetAttribute,-1),i[n++]=o._arcType,i[n]=o.packedLength,i};const nt=e.Ellipsoid.clone(e.Ellipsoid.UNIT_SPHERE),rt=new h.VertexFormat,at={polygonHierarchy:{}};return it.unpack=function(o,i,n){i=t.defaultValue(i,0);const r=g.PolygonGeometryLibrary.unpackPolygonHierarchy(o,i);i=r.startingIndex,delete r.startingIndex;const a=e.Ellipsoid.unpack(o,i,nt);i+=e.Ellipsoid.packedLength;const s=h.VertexFormat.unpack(o,i,rt);i+=h.VertexFormat.packedLength;const l=o[i++],c=o[i++],u=o[i++],p=o[i++],m=1===o[i++],y=1===o[i++],d=1===o[i++],f=1===o[i++],b=1===o[i++],_=o[i++],P=o[i++],x=o[i];return t.defined(n)||(n=new it(at)),n._polygonHierarchy=r,n._ellipsoid=e.Ellipsoid.clone(a,n._ellipsoid),n._vertexFormat=h.VertexFormat.clone(s,n._vertexFormat),n._height=l,n._extrudedHeight=c,n._granularity=u,n._stRotation=p,n._perPositionHeightExtrude=m,n._perPositionHeight=y,n._closeTop=d,n._closeBottom=f,n._shadowVolume=b,n._offsetAttribute=-1===_?void 0:_,n._arcType=P,n.packedLength=x,n},it.computeRectangle=function(i,n){const r=t.defaultValue(i.granularity,s.CesiumMath.RADIANS_PER_DEGREE),a=t.defaultValue(i.arcType,o.ArcType.GEODESIC),l=i.polygonHierarchy,c=t.defaultValue(i.ellipsoid,e.Ellipsoid.WGS84);return X(l.positions,c,a,r,n)},it.createGeometry=function(e){const o=e._vertexFormat,n=e._ellipsoid,a=e._granularity,l=e._stRotation,h=e._polygonHierarchy,f=e._perPositionHeight,b=e._closeTop,_=e._closeBottom,P=e._arcType;let x=h.positions;if(x.length<3)return;const C=c.EllipsoidTangentPlane.fromPoints(x,n),w=g.PolygonGeometryLibrary.polygonsFromHierarchy(h,C.projectPointsOntoPlane.bind(C),!f,n),T=w.hierarchy,I=w.polygons;if(0===T.length)return;x=T[0].outerRing;const A=g.PolygonGeometryLibrary.computeBoundingRectangle(C.plane.normal,C.projectPointOntoPlane.bind(C),x,l,V),E=[],v=e._height,G=e._extrudedHeight,O={perPositionHeight:f,vertexFormat:o,geometry:void 0,tangentPlane:C,boundingRectangle:A,ellipsoid:n,stRotation:l,bottom:!1,top:!0,wall:!1,extrude:!1,arcType:P};let F;if(e._perPositionHeightExtrude||!s.CesiumMath.equalsEpsilon(v,G,0,s.CesiumMath.EPSILON2))for(O.extrude=!0,O.top=b,O.bottom=_,O.shadowVolume=e._shadowVolume,O.offsetAttribute=e._offsetAttribute,F=0;F<I.length;F++){const t=ot(n,I[F],a,T[F],f,b,_,o,P);let e;b&&_?(e=t.topAndBottom,O.geometry=g.PolygonGeometryLibrary.scaleToGeodeticHeightExtruded(e.geometry,v,G,n,f)):b?(e=t.topAndBottom,e.geometry.attributes.position.values=d.PolygonPipeline.scaleToGeodeticHeight(e.geometry.attributes.position.values,v,n,!f),O.geometry=e.geometry):_&&(e=t.topAndBottom,e.geometry.attributes.position.values=d.PolygonPipeline.scaleToGeodeticHeight(e.geometry.attributes.position.values,G,n,!0),O.geometry=e.geometry),(b||_)&&(O.wall=!1,e.geometry=Q(O),E.push(e));const i=t.walls;O.wall=!0;for(let t=0;t<i.length;t++){const e=i[t];O.geometry=g.PolygonGeometryLibrary.scaleToGeodeticHeightExtruded(e.geometry,v,G,n,f),e.geometry=Q(O),E.push(e)}}else for(F=0;F<I.length;F++){const r=new p.GeometryInstance({geometry:g.PolygonGeometryLibrary.createGeometryFromPositions(n,I[F],a,f,o,P)});if(r.geometry.attributes.position.values=d.PolygonPipeline.scaleToGeodeticHeight(r.geometry.attributes.position.values,v,n,!f),O.geometry=r.geometry,r.geometry=Q(O),t.defined(e._offsetAttribute)){const t=r.geometry.attributes.position.values.length,o=new Uint8Array(t/3),n=e._offsetAttribute===i.GeometryOffsetAttribute.NONE?0:1;i.arrayFill(o,n),r.geometry.attributes.applyOffset=new u.GeometryAttribute({componentDatatype:s.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:1,values:o})}E.push(r)}const D=m.GeometryPipeline.combineInstances(E)[0];D.attributes.position.values=new Float64Array(D.attributes.position.values),D.indices=y.IndexDatatype.createTypedArray(D.attributes.position.values.length/3,D.indices);const L=D.attributes,N=r.BoundingSphere.fromVertices(L.position.values);return o.position||delete L.position,new u.Geometry({attributes:L,indices:D.indices,primitiveType:D.primitiveType,boundingSphere:N,offsetAttribute:e._offsetAttribute})},it.createShadowVolume=function(t,e,o){const i=t._granularity,n=t._ellipsoid,r=e(i,n),a=o(i,n);return new it({polygonHierarchy:t._polygonHierarchy,ellipsoid:n,stRotation:t._stRotation,granularity:i,perPositionHeight:!1,extrudedHeight:r,height:a,vertexFormat:h.VertexFormat.POSITION_ONLY,shadowVolume:!0,arcType:t._arcType})},Object.defineProperties(it.prototype,{rectangle:{get:function(){if(!t.defined(this._rectangle)){const t=this._polygonHierarchy.positions;this._rectangle=X(t,this._ellipsoid,this._arcType,this._granularity)}return this._rectangle}},textureCoordinateRotationPoints:{get:function(){return t.defined(this._textureCoordinateRotationPoints)||(this._textureCoordinateRotationPoints=function(t){const e=-t._stRotation;if(0===e)return[0,0,0,1,1,0];const o=t._ellipsoid,i=t._polygonHierarchy.positions,n=t.rectangle;return u.Geometry._textureCoordinateRotationPoints(i,e,o,n)}(this)),this._textureCoordinateRotationPoints}}}),function(o,i){return t.defined(i)&&(o=it.unpack(o,i)),o._ellipsoid=e.Ellipsoid.clone(o._ellipsoid),it.createGeometry(o)}}));
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.109.3
+ *
+ * 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-66QLLS45.js";
+import {
+  PolygonGeometryLibrary_default
+} from "./chunk-KTJSNCK4.js";
+import {
+  ArcType_default
+} from "./chunk-CCFQRR6D.js";
+import {
+  GeometryInstance_default
+} from "./chunk-227AJNOA.js";
+import {
+  GeometryPipeline_default
+} from "./chunk-XTY7B2N6.js";
+import "./chunk-O5AMBQ36.js";
+import "./chunk-QT3MPEMI.js";
+import {
+  EllipsoidGeodesic_default
+} from "./chunk-AFFLIKOH.js";
+import {
+  GeometryOffsetAttribute_default
+} from "./chunk-MPAZH4BF.js";
+import {
+  VertexFormat_default
+} from "./chunk-QMEMZIJI.js";
+import {
+  EllipsoidTangentPlane_default
+} from "./chunk-RP2A7BR5.js";
+import "./chunk-2R5O53JW.js";
+import {
+  PolygonPipeline_default,
+  WindingOrder_default
+} from "./chunk-J3JY6I2C.js";
+import "./chunk-3W63OHNJ.js";
+import "./chunk-K36FEYS7.js";
+import "./chunk-MYZB7C4T.js";
+import "./chunk-OYFCF4PL.js";
+import {
+  IndexDatatype_default
+} from "./chunk-RW6LU2CJ.js";
+import "./chunk-EW2GWJYB.js";
+import {
+  GeometryAttribute_default,
+  Geometry_default
+} from "./chunk-X4SU25DT.js";
+import {
+  BoundingSphere_default,
+  Quaternion_default
+} from "./chunk-PFQBCKBM.js";
+import "./chunk-QJ3DFBH3.js";
+import {
+  Cartesian2_default,
+  Rectangle_default
+} from "./chunk-DUHWWBQQ.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-LLUNNUJV.js";
+import {
+  Cartesian3_default,
+  Cartographic_default,
+  Ellipsoid_default,
+  Matrix3_default
+} from "./chunk-PCJWUS4M.js";
+import {
+  Math_default
+} from "./chunk-N3JIFFX2.js";
+import "./chunk-AHKEZ2OE.js";
+import "./chunk-ABADGKYE.js";
+import {
+  defaultValue_default
+} from "./chunk-WXTV4ATB.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-4MFFIWUA.js";
+import {
+  defined_default
+} from "./chunk-6BTKZDRG.js";
+
+// 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 tangentPlane = options.tangentPlane;
+    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(
+        tangentPlane._plane.normal,
+        stRotation,
+        appendTextureCoordinatesQuaternion
+      );
+      textureMatrix = Matrix3_default.fromQuaternion(rotation, textureMatrix);
+      rotation = Quaternion_default.fromAxisAngle(
+        tangentPlane._plane.normal,
+        -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 = tangentPlane.projectPointOntoPlane(
+            p,
+            appendTextureCoordinatesCartesian2
+          );
+          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 startCartographicScratch = new Cartographic_default();
+var endCartographicScratch = new Cartographic_default();
+var idlCross = {
+  westOverIDL: 0,
+  eastOverIDL: 0
+};
+var ellipsoidGeodesic = new EllipsoidGeodesic_default();
+function computeRectangle(positions, ellipsoid, arcType, granularity, result) {
+  result = defaultValue_default(result, new Rectangle_default());
+  if (!defined_default(positions) || positions.length < 3) {
+    result.west = 0;
+    result.north = 0;
+    result.south = 0;
+    result.east = 0;
+    return result;
+  }
+  if (arcType === ArcType_default.RHUMB) {
+    return Rectangle_default.fromCartesianArray(positions, ellipsoid, result);
+  }
+  if (!ellipsoidGeodesic.ellipsoid.equals(ellipsoid)) {
+    ellipsoidGeodesic = new EllipsoidGeodesic_default(void 0, void 0, ellipsoid);
+  }
+  result.west = Number.POSITIVE_INFINITY;
+  result.east = Number.NEGATIVE_INFINITY;
+  result.south = Number.POSITIVE_INFINITY;
+  result.north = Number.NEGATIVE_INFINITY;
+  idlCross.westOverIDL = Number.POSITIVE_INFINITY;
+  idlCross.eastOverIDL = Number.NEGATIVE_INFINITY;
+  const inverseChordLength = 1 / Math_default.chordLength(granularity, ellipsoid.maximumRadius);
+  const positionsLength = positions.length;
+  let endCartographic = ellipsoid.cartesianToCartographic(
+    positions[0],
+    endCartographicScratch
+  );
+  let startCartographic = startCartographicScratch;
+  let swap;
+  for (let i = 1; i < positionsLength; i++) {
+    swap = startCartographic;
+    startCartographic = endCartographic;
+    endCartographic = ellipsoid.cartesianToCartographic(positions[i], swap);
+    ellipsoidGeodesic.setEndPoints(startCartographic, endCartographic);
+    interpolateAndGrowRectangle(
+      ellipsoidGeodesic,
+      inverseChordLength,
+      result,
+      idlCross
+    );
+  }
+  swap = startCartographic;
+  startCartographic = endCartographic;
+  endCartographic = ellipsoid.cartesianToCartographic(positions[0], swap);
+  ellipsoidGeodesic.setEndPoints(startCartographic, endCartographic);
+  interpolateAndGrowRectangle(
+    ellipsoidGeodesic,
+    inverseChordLength,
+    result,
+    idlCross
+  );
+  if (result.east - result.west > idlCross.eastOverIDL - idlCross.westOverIDL) {
+    result.west = idlCross.westOverIDL;
+    result.east = idlCross.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;
+    }
+  }
+  return result;
+}
+var interpolatedCartographicScratch = new Cartographic_default();
+function interpolateAndGrowRectangle(ellipsoidGeodesic2, inverseChordLength, result, idlCross2) {
+  const segmentLength = ellipsoidGeodesic2.surfaceDistance;
+  const numPoints = Math.ceil(segmentLength * inverseChordLength);
+  const subsegmentDistance = numPoints > 0 ? segmentLength / (numPoints - 1) : Number.POSITIVE_INFINITY;
+  let interpolationDistance = 0;
+  for (let i = 0; i < numPoints; i++) {
+    const interpolatedCartographic = ellipsoidGeodesic2.interpolateUsingSurfaceDistance(
+      interpolationDistance,
+      interpolatedCartographicScratch
+    );
+    interpolationDistance += subsegmentDistance;
+    const longitude = interpolatedCartographic.longitude;
+    const latitude = interpolatedCartographic.latitude;
+    result.west = Math.min(result.west, longitude);
+    result.east = Math.max(result.east, longitude);
+    result.south = Math.min(result.south, latitude);
+    result.north = Math.max(result.north, latitude);
+    const lonAdjusted = longitude >= 0 ? longitude : longitude + Math_default.TWO_PI;
+    idlCross2.westOverIDL = Math.min(idlCross2.westOverIDL, lonAdjusted);
+    idlCross2.eastOverIDL = Math.max(idlCross2.eastOverIDL, lonAdjusted);
+  }
+}
+var createGeometryFromPositionsExtrudedPositions = [];
+function createGeometryFromPositionsExtruded(ellipsoid, polygon, textureCoordinates, granularity, hierarchy, perPositionHeight, closeTop, closeBottom, vertexFormat, arcType) {
+  const geos = {
+    walls: []
+  };
+  let i;
+  if (closeTop || closeBottom) {
+    const topGeo = PolygonGeometryLibrary_default.createGeometryFromPositions(
+      ellipsoid,
+      polygon,
+      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;
+  let 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];
+    tangentPlane = EllipsoidTangentPlane_default.fromPoints(hole, ellipsoid);
+    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.WGS84);
+  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;
+};
+PolygonGeometry.computeRectangle = function(options, result) {
+  Check_default.typeOf.object("options", options);
+  Check_default.typeOf.object("options.polygonHierarchy", options.polygonHierarchy);
+  const granularity = defaultValue_default(
+    options.granularity,
+    Math_default.RADIANS_PER_DEGREE
+  );
+  const arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
+  if (arcType !== ArcType_default.GEODESIC && 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.WGS84);
+  return computeRectangle(
+    polygonHierarchy.positions,
+    ellipsoid,
+    arcType,
+    granularity,
+    result
+  );
+};
+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);
+  let outerPositions = polygonHierarchy.positions;
+  if (outerPositions.length < 3) {
+    return;
+  }
+  const tangentPlane = EllipsoidTangentPlane_default.fromPoints(
+    outerPositions,
+    ellipsoid
+  );
+  const results = PolygonGeometryLibrary_default.polygonsFromHierarchy(
+    polygonHierarchy,
+    hasTextureCoordinates,
+    tangentPlane.projectPointsOntoPlane.bind(tangentPlane),
+    !perPositionHeight,
+    ellipsoid
+  );
+  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 boundingRectangle = PolygonGeometryLibrary_default.computeBoundingRectangle(
+    tangentPlane.plane.normal,
+    tangentPlane.projectPointOntoPlane.bind(tangentPlane),
+    outerPositions,
+    stRotation,
+    scratchBoundingRectangle
+  );
+  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,
+    tangentPlane,
+    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 = computeRectangle(
+          positions,
+          this._ellipsoid,
+          this._arcType,
+          this._granularity
+        );
+      }
+      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
+};