@vcmap/ui 5.0.0-rc.9 → 5.0.0

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

@@ -1 +1,384 @@
-define(["./AttributeCompression-80665726","./Matrix2-47e98d76","./Color-de06a177","./defaultValue-81eec7ed","./IndexDatatype-f1dcdf35","./ComponentDatatype-a15c9a19","./OrientedBoundingBox-fcb5b750","./createTaskProcessorWorker","./RuntimeError-8952249c","./Transforms-c8cb8f43","./_commonjsHelpers-3aae1032-26891ab7","./combine-3c023bda","./WebGLConstants-508b9636","./EllipsoidTangentPlane-a01286f6","./AxisAlignedBoundingBox-a655a4bc","./IntersectionTests-58aa8f80","./Plane-3f01019d"],(function(e,t,n,a,r,o,s,i,c,f,d,l,u,h,g,p,b){"use strict";const m=new t.Cartesian3,y=new t.Ellipsoid,C=new t.Rectangle,I={min:void 0,max:void 0,indexBytesPerElement:void 0};function x(e,t,a){const r=t.length,o=2+r*s.OrientedBoundingBox.packedLength+1+function(e){const t=e.length;let a=0;for(let r=0;r<t;++r)a+=n.Color.packedLength+3+e[r].batchIds.length;return a}(a),i=new Float64Array(o);let c=0;i[c++]=e,i[c++]=r;for(let e=0;e<r;++e)s.OrientedBoundingBox.pack(t[e],i,c),c+=s.OrientedBoundingBox.packedLength;const f=a.length;i[c++]=f;for(let e=0;e<f;++e){const t=a[e];n.Color.pack(t.color,i,c),c+=n.Color.packedLength,i[c++]=t.offset,i[c++]=t.count;const r=t.batchIds,o=r.length;i[c++]=o;for(let e=0;e<o;++e)i[c++]=r[e]}return i}const w=new t.Cartesian3,A=new t.Cartesian3,E=new t.Cartesian3,N=new t.Cartesian3,T=new t.Cartesian3,B=new t.Cartographic,k=new t.Rectangle;return i((function(i,c){let f;!function(e){const n=new Float64Array(e);let a=0;I.indexBytesPerElement=n[a++],I.min=n[a++],I.max=n[a++],t.Cartesian3.unpack(n,a,m),a+=t.Cartesian3.packedLength,t.Ellipsoid.unpack(n,a,y),a+=t.Ellipsoid.packedLength,t.Rectangle.unpack(n,a,C)}(i.packedBuffer),f=2===I.indexBytesPerElement?new Uint16Array(i.indices):new Uint32Array(i.indices);const d=new Uint16Array(i.positions),l=new Uint32Array(i.counts),u=new Uint32Array(i.indexCounts),h=new Uint32Array(i.batchIds),g=new Uint32Array(i.batchTableColors),p=new Array(l.length),b=m,L=y;let O=C;const U=I.min,P=I.max;let F,S,D,R=i.minimumHeights,_=i.maximumHeights;a.defined(R)&&a.defined(_)&&(R=new Float32Array(R),_=new Float32Array(_));const M=d.length/2,G=d.subarray(0,M),V=d.subarray(M,2*M);e.AttributeCompression.zigZagDeltaDecode(G,V);const Y=new Float64Array(3*M);for(F=0;F<M;++F){const e=G[F],n=V[F],a=o.CesiumMath.lerp(O.west,O.east,e/32767),r=o.CesiumMath.lerp(O.south,O.north,n/32767),s=t.Cartographic.fromRadians(a,r,0,B),i=L.cartographicToCartesian(s,w);t.Cartesian3.pack(i,Y,3*F)}const H=l.length,v=new Array(H),W=new Array(H);let j=0,z=0;for(F=0;F<H;++F)v[F]=j,W[F]=z,j+=l[F],z+=u[F];const Z=new Float32Array(3*M*2),q=new Uint16Array(2*M),J=new Uint32Array(W.length),K=new Uint32Array(u.length);let Q=[];const X={};for(F=0;F<H;++F)D=g[F],a.defined(X[D])?(X[D].positionLength+=l[F],X[D].indexLength+=u[F],X[D].batchIds.push(F)):X[D]={positionLength:l[F],indexLength:u[F],offset:0,indexOffset:0,batchIds:[F]};let $,ee=0,te=0;for(D in X)if(X.hasOwnProperty(D)){$=X[D],$.offset=ee,$.indexOffset=te;const e=2*$.positionLength,t=2*$.indexLength+6*$.positionLength;ee+=e,te+=t,$.indexLength=t}const ne=[];for(D in X)X.hasOwnProperty(D)&&($=X[D],ne.push({color:n.Color.fromRgba(parseInt(D)),offset:$.indexOffset,count:$.indexLength,batchIds:$.batchIds}));for(F=0;F<H;++F){D=g[F],$=X[D];const e=$.offset;let n=3*e,r=e;const o=v[F],i=l[F],c=h[F];let d=U,m=P;a.defined(R)&&a.defined(_)&&(d=R[F],m=_[F]);let y=Number.POSITIVE_INFINITY,C=Number.NEGATIVE_INFINITY,I=Number.POSITIVE_INFINITY,x=Number.NEGATIVE_INFINITY;for(S=0;S<i;++S){const e=t.Cartesian3.unpack(Y,3*o+3*S,w);L.scaleToGeodeticSurface(e,e);const a=L.cartesianToCartographic(e,B),s=a.latitude,i=a.longitude;y=Math.min(s,y),C=Math.max(s,C),I=Math.min(i,I),x=Math.max(i,x);const f=L.geodeticSurfaceNormal(e,A);let l=t.Cartesian3.multiplyByScalar(f,d,E);const u=t.Cartesian3.add(e,l,N);l=t.Cartesian3.multiplyByScalar(f,m,l);const h=t.Cartesian3.add(e,l,T);t.Cartesian3.subtract(h,b,h),t.Cartesian3.subtract(u,b,u),t.Cartesian3.pack(h,Z,n),t.Cartesian3.pack(u,Z,n+3),q[r]=c,q[r+1]=c,n+=6,r+=2}O=k,O.west=I,O.east=x,O.south=y,O.north=C,p[F]=s.OrientedBoundingBox.fromRectangle(O,U,P,L);let M=$.indexOffset;const G=W[F],V=u[F];for(J[F]=M,S=0;S<V;S+=3){const t=f[G+S]-o,n=f[G+S+1]-o,a=f[G+S+2]-o;Q[M++]=2*t+e,Q[M++]=2*n+e,Q[M++]=2*a+e,Q[M++]=2*a+1+e,Q[M++]=2*n+1+e,Q[M++]=2*t+1+e}for(S=0;S<i;++S){const t=S,n=(S+1)%i;Q[M++]=2*t+1+e,Q[M++]=2*n+e,Q[M++]=2*t+e,Q[M++]=2*t+1+e,Q[M++]=2*n+1+e,Q[M++]=2*n+e}$.offset+=2*i,$.indexOffset=M,K[F]=M-J[F]}Q=r.IndexDatatype.createTypedArray(Z.length/3,Q);const ae=ne.length;for(let e=0;e<ae;++e){const t=ne[e].batchIds;let n=0;const a=t.length;for(let e=0;e<a;++e)n+=K[t[e]];ne[e].count=n}const re=x(2===Q.BYTES_PER_ELEMENT?r.IndexDatatype.UNSIGNED_SHORT:r.IndexDatatype.UNSIGNED_INT,p,ne);return c.push(Z.buffer,Q.buffer,J.buffer,K.buffer,q.buffer,re.buffer),{positions:Z.buffer,indices:Q.buffer,indexOffsets:J.buffer,indexCounts:K.buffer,batchIds:q.buffer,packedBuffer:re.buffer}}))}));
+/**
+ * @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 {
+  Color_default
+} from "./chunk-JS3AW5BK.js";
+import {
+  createTaskProcessorWorker_default
+} from "./chunk-A4JVFBQ3.js";
+import {
+  OrientedBoundingBox_default
+} from "./chunk-Z24VKNDO.js";
+import {
+  AttributeCompression_default
+} from "./chunk-O5AMBQ36.js";
+import "./chunk-RP2A7BR5.js";
+import "./chunk-2R5O53JW.js";
+import "./chunk-MYZB7C4T.js";
+import "./chunk-OYFCF4PL.js";
+import {
+  IndexDatatype_default
+} from "./chunk-RW6LU2CJ.js";
+import "./chunk-PFQBCKBM.js";
+import "./chunk-QJ3DFBH3.js";
+import {
+  Rectangle_default
+} from "./chunk-DUHWWBQQ.js";
+import "./chunk-LLUNNUJV.js";
+import {
+  Cartesian3_default,
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-PCJWUS4M.js";
+import {
+  Math_default
+} from "./chunk-N3JIFFX2.js";
+import "./chunk-AHKEZ2OE.js";
+import "./chunk-ABADGKYE.js";
+import "./chunk-WXTV4ATB.js";
+import "./chunk-4MFFIWUA.js";
+import {
+  defined_default
+} from "./chunk-6BTKZDRG.js";
+
+// packages/engine/Source/Workers/createVectorTilePolygons.js
+var scratchCenter = new Cartesian3_default();
+var scratchEllipsoid = new Ellipsoid_default();
+var scratchRectangle = new Rectangle_default();
+var scratchScalars = {
+  min: void 0,
+  max: void 0,
+  indexBytesPerElement: void 0
+};
+function unpackBuffer(buffer) {
+  const packedBuffer = new Float64Array(buffer);
+  let offset = 0;
+  scratchScalars.indexBytesPerElement = packedBuffer[offset++];
+  scratchScalars.min = packedBuffer[offset++];
+  scratchScalars.max = packedBuffer[offset++];
+  Cartesian3_default.unpack(packedBuffer, offset, scratchCenter);
+  offset += Cartesian3_default.packedLength;
+  Ellipsoid_default.unpack(packedBuffer, offset, scratchEllipsoid);
+  offset += Ellipsoid_default.packedLength;
+  Rectangle_default.unpack(packedBuffer, offset, scratchRectangle);
+}
+function packedBatchedIndicesLength(batchedIndices) {
+  const length = batchedIndices.length;
+  let count = 0;
+  for (let i = 0; i < length; ++i) {
+    count += Color_default.packedLength + 3 + batchedIndices[i].batchIds.length;
+  }
+  return count;
+}
+function packBuffer(indexDatatype, boundingVolumes, batchedIndices) {
+  const numBVs = boundingVolumes.length;
+  const length = 1 + 1 + numBVs * OrientedBoundingBox_default.packedLength + 1 + packedBatchedIndicesLength(batchedIndices);
+  const packedBuffer = new Float64Array(length);
+  let offset = 0;
+  packedBuffer[offset++] = indexDatatype;
+  packedBuffer[offset++] = numBVs;
+  for (let i = 0; i < numBVs; ++i) {
+    OrientedBoundingBox_default.pack(boundingVolumes[i], packedBuffer, offset);
+    offset += OrientedBoundingBox_default.packedLength;
+  }
+  const indicesLength = batchedIndices.length;
+  packedBuffer[offset++] = indicesLength;
+  for (let j = 0; j < indicesLength; ++j) {
+    const batchedIndex = batchedIndices[j];
+    Color_default.pack(batchedIndex.color, packedBuffer, offset);
+    offset += Color_default.packedLength;
+    packedBuffer[offset++] = batchedIndex.offset;
+    packedBuffer[offset++] = batchedIndex.count;
+    const batchIds = batchedIndex.batchIds;
+    const batchIdsLength = batchIds.length;
+    packedBuffer[offset++] = batchIdsLength;
+    for (let k = 0; k < batchIdsLength; ++k) {
+      packedBuffer[offset++] = batchIds[k];
+    }
+  }
+  return packedBuffer;
+}
+var maxShort = 32767;
+var scratchEncodedPosition = new Cartesian3_default();
+var scratchNormal = new Cartesian3_default();
+var scratchScaledNormal = new Cartesian3_default();
+var scratchMinHeightPosition = new Cartesian3_default();
+var scratchMaxHeightPosition = new Cartesian3_default();
+var scratchBVCartographic = new Cartographic_default();
+var scratchBVRectangle = new Rectangle_default();
+function createVectorTilePolygons(parameters, transferableObjects) {
+  unpackBuffer(parameters.packedBuffer);
+  let indices;
+  const indexBytesPerElement = scratchScalars.indexBytesPerElement;
+  if (indexBytesPerElement === 2) {
+    indices = new Uint16Array(parameters.indices);
+  } else {
+    indices = new Uint32Array(parameters.indices);
+  }
+  const positions = new Uint16Array(parameters.positions);
+  const counts = new Uint32Array(parameters.counts);
+  const indexCounts = new Uint32Array(parameters.indexCounts);
+  const batchIds = new Uint32Array(parameters.batchIds);
+  const batchTableColors = new Uint32Array(parameters.batchTableColors);
+  const boundingVolumes = new Array(counts.length);
+  const center = scratchCenter;
+  const ellipsoid = scratchEllipsoid;
+  let rectangle = scratchRectangle;
+  const minHeight = scratchScalars.min;
+  const maxHeight = scratchScalars.max;
+  let minimumHeights = parameters.minimumHeights;
+  let maximumHeights = parameters.maximumHeights;
+  if (defined_default(minimumHeights) && defined_default(maximumHeights)) {
+    minimumHeights = new Float32Array(minimumHeights);
+    maximumHeights = new Float32Array(maximumHeights);
+  }
+  let i;
+  let j;
+  let rgba;
+  const positionsLength = positions.length / 2;
+  const uBuffer = positions.subarray(0, positionsLength);
+  const vBuffer = positions.subarray(positionsLength, 2 * positionsLength);
+  AttributeCompression_default.zigZagDeltaDecode(uBuffer, vBuffer);
+  const decodedPositions = new Float64Array(positionsLength * 3);
+  for (i = 0; i < positionsLength; ++i) {
+    const u = uBuffer[i];
+    const v = vBuffer[i];
+    const x = Math_default.lerp(rectangle.west, rectangle.east, u / maxShort);
+    const y = Math_default.lerp(rectangle.south, rectangle.north, v / maxShort);
+    const cart = Cartographic_default.fromRadians(x, y, 0, scratchBVCartographic);
+    const decodedPosition = ellipsoid.cartographicToCartesian(
+      cart,
+      scratchEncodedPosition
+    );
+    Cartesian3_default.pack(decodedPosition, decodedPositions, i * 3);
+  }
+  const countsLength = counts.length;
+  const offsets = new Array(countsLength);
+  const indexOffsets = new Array(countsLength);
+  let currentOffset = 0;
+  let currentIndexOffset = 0;
+  for (i = 0; i < countsLength; ++i) {
+    offsets[i] = currentOffset;
+    indexOffsets[i] = currentIndexOffset;
+    currentOffset += counts[i];
+    currentIndexOffset += indexCounts[i];
+  }
+  const batchedPositions = new Float32Array(positionsLength * 3 * 2);
+  const batchedIds = new Uint16Array(positionsLength * 2);
+  const batchedIndexOffsets = new Uint32Array(indexOffsets.length);
+  const batchedIndexCounts = new Uint32Array(indexCounts.length);
+  let batchedIndices = [];
+  const colorToBuffers = {};
+  for (i = 0; i < countsLength; ++i) {
+    rgba = batchTableColors[i];
+    if (!defined_default(colorToBuffers[rgba])) {
+      colorToBuffers[rgba] = {
+        positionLength: counts[i],
+        indexLength: indexCounts[i],
+        offset: 0,
+        indexOffset: 0,
+        batchIds: [i]
+      };
+    } else {
+      colorToBuffers[rgba].positionLength += counts[i];
+      colorToBuffers[rgba].indexLength += indexCounts[i];
+      colorToBuffers[rgba].batchIds.push(i);
+    }
+  }
+  let buffer;
+  let byColorPositionOffset = 0;
+  let byColorIndexOffset = 0;
+  for (rgba in colorToBuffers) {
+    if (colorToBuffers.hasOwnProperty(rgba)) {
+      buffer = colorToBuffers[rgba];
+      buffer.offset = byColorPositionOffset;
+      buffer.indexOffset = byColorIndexOffset;
+      const positionLength = buffer.positionLength * 2;
+      const indexLength = buffer.indexLength * 2 + buffer.positionLength * 6;
+      byColorPositionOffset += positionLength;
+      byColorIndexOffset += indexLength;
+      buffer.indexLength = indexLength;
+    }
+  }
+  const batchedDrawCalls = [];
+  for (rgba in colorToBuffers) {
+    if (colorToBuffers.hasOwnProperty(rgba)) {
+      buffer = colorToBuffers[rgba];
+      batchedDrawCalls.push({
+        color: Color_default.fromRgba(parseInt(rgba)),
+        offset: buffer.indexOffset,
+        count: buffer.indexLength,
+        batchIds: buffer.batchIds
+      });
+    }
+  }
+  for (i = 0; i < countsLength; ++i) {
+    rgba = batchTableColors[i];
+    buffer = colorToBuffers[rgba];
+    const positionOffset = buffer.offset;
+    let positionIndex = positionOffset * 3;
+    let batchIdIndex = positionOffset;
+    const polygonOffset = offsets[i];
+    const polygonCount = counts[i];
+    const batchId = batchIds[i];
+    let polygonMinimumHeight = minHeight;
+    let polygonMaximumHeight = maxHeight;
+    if (defined_default(minimumHeights) && defined_default(maximumHeights)) {
+      polygonMinimumHeight = minimumHeights[i];
+      polygonMaximumHeight = maximumHeights[i];
+    }
+    let minLat = Number.POSITIVE_INFINITY;
+    let maxLat = Number.NEGATIVE_INFINITY;
+    let minLon = Number.POSITIVE_INFINITY;
+    let maxLon = Number.NEGATIVE_INFINITY;
+    for (j = 0; j < polygonCount; ++j) {
+      const position = Cartesian3_default.unpack(
+        decodedPositions,
+        polygonOffset * 3 + j * 3,
+        scratchEncodedPosition
+      );
+      ellipsoid.scaleToGeodeticSurface(position, position);
+      const carto = ellipsoid.cartesianToCartographic(
+        position,
+        scratchBVCartographic
+      );
+      const lat = carto.latitude;
+      const lon = carto.longitude;
+      minLat = Math.min(lat, minLat);
+      maxLat = Math.max(lat, maxLat);
+      minLon = Math.min(lon, minLon);
+      maxLon = Math.max(lon, maxLon);
+      const normal = ellipsoid.geodeticSurfaceNormal(position, scratchNormal);
+      let scaledNormal = Cartesian3_default.multiplyByScalar(
+        normal,
+        polygonMinimumHeight,
+        scratchScaledNormal
+      );
+      const minHeightPosition = Cartesian3_default.add(
+        position,
+        scaledNormal,
+        scratchMinHeightPosition
+      );
+      scaledNormal = Cartesian3_default.multiplyByScalar(
+        normal,
+        polygonMaximumHeight,
+        scaledNormal
+      );
+      const maxHeightPosition = Cartesian3_default.add(
+        position,
+        scaledNormal,
+        scratchMaxHeightPosition
+      );
+      Cartesian3_default.subtract(maxHeightPosition, center, maxHeightPosition);
+      Cartesian3_default.subtract(minHeightPosition, center, minHeightPosition);
+      Cartesian3_default.pack(maxHeightPosition, batchedPositions, positionIndex);
+      Cartesian3_default.pack(minHeightPosition, batchedPositions, positionIndex + 3);
+      batchedIds[batchIdIndex] = batchId;
+      batchedIds[batchIdIndex + 1] = batchId;
+      positionIndex += 6;
+      batchIdIndex += 2;
+    }
+    rectangle = scratchBVRectangle;
+    rectangle.west = minLon;
+    rectangle.east = maxLon;
+    rectangle.south = minLat;
+    rectangle.north = maxLat;
+    boundingVolumes[i] = OrientedBoundingBox_default.fromRectangle(
+      rectangle,
+      minHeight,
+      maxHeight,
+      ellipsoid
+    );
+    let indicesIndex = buffer.indexOffset;
+    const indexOffset = indexOffsets[i];
+    const indexCount = indexCounts[i];
+    batchedIndexOffsets[i] = indicesIndex;
+    for (j = 0; j < indexCount; j += 3) {
+      const i0 = indices[indexOffset + j] - polygonOffset;
+      const i1 = indices[indexOffset + j + 1] - polygonOffset;
+      const i2 = indices[indexOffset + j + 2] - polygonOffset;
+      batchedIndices[indicesIndex++] = i0 * 2 + positionOffset;
+      batchedIndices[indicesIndex++] = i1 * 2 + positionOffset;
+      batchedIndices[indicesIndex++] = i2 * 2 + positionOffset;
+      batchedIndices[indicesIndex++] = i2 * 2 + 1 + positionOffset;
+      batchedIndices[indicesIndex++] = i1 * 2 + 1 + positionOffset;
+      batchedIndices[indicesIndex++] = i0 * 2 + 1 + positionOffset;
+    }
+    for (j = 0; j < polygonCount; ++j) {
+      const v0 = j;
+      const v1 = (j + 1) % polygonCount;
+      batchedIndices[indicesIndex++] = v0 * 2 + 1 + positionOffset;
+      batchedIndices[indicesIndex++] = v1 * 2 + positionOffset;
+      batchedIndices[indicesIndex++] = v0 * 2 + positionOffset;
+      batchedIndices[indicesIndex++] = v0 * 2 + 1 + positionOffset;
+      batchedIndices[indicesIndex++] = v1 * 2 + 1 + positionOffset;
+      batchedIndices[indicesIndex++] = v1 * 2 + positionOffset;
+    }
+    buffer.offset += polygonCount * 2;
+    buffer.indexOffset = indicesIndex;
+    batchedIndexCounts[i] = indicesIndex - batchedIndexOffsets[i];
+  }
+  batchedIndices = IndexDatatype_default.createTypedArray(
+    batchedPositions.length / 3,
+    batchedIndices
+  );
+  const batchedIndicesLength = batchedDrawCalls.length;
+  for (let m = 0; m < batchedIndicesLength; ++m) {
+    const tempIds = batchedDrawCalls[m].batchIds;
+    let count = 0;
+    const tempIdsLength = tempIds.length;
+    for (let n = 0; n < tempIdsLength; ++n) {
+      count += batchedIndexCounts[tempIds[n]];
+    }
+    batchedDrawCalls[m].count = count;
+  }
+  const indexDatatype = batchedIndices.BYTES_PER_ELEMENT === 2 ? IndexDatatype_default.UNSIGNED_SHORT : IndexDatatype_default.UNSIGNED_INT;
+  const packedBuffer = packBuffer(
+    indexDatatype,
+    boundingVolumes,
+    batchedDrawCalls
+  );
+  transferableObjects.push(
+    batchedPositions.buffer,
+    batchedIndices.buffer,
+    batchedIndexOffsets.buffer,
+    batchedIndexCounts.buffer,
+    batchedIds.buffer,
+    packedBuffer.buffer
+  );
+  return {
+    positions: batchedPositions.buffer,
+    indices: batchedIndices.buffer,
+    indexOffsets: batchedIndexOffsets.buffer,
+    indexCounts: batchedIndexCounts.buffer,
+    batchIds: batchedIds.buffer,
+    packedBuffer: packedBuffer.buffer
+  };
+}
+var createVectorTilePolygons_default = createTaskProcessorWorker_default(createVectorTilePolygons);
+export {
+  createVectorTilePolygons_default as default
+};

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

@@ -1 +1,262 @@
-define(["./Matrix2-47e98d76","./combine-3c023bda","./AttributeCompression-80665726","./ComponentDatatype-a15c9a19","./IndexDatatype-f1dcdf35","./createTaskProcessorWorker","./RuntimeError-8952249c","./defaultValue-81eec7ed","./WebGLConstants-508b9636"],(function(e,t,a,n,r,s,i,o,c){"use strict";const u=32767,f=new e.Cartographic,p=new e.Cartesian3;const d=new e.Rectangle,l=new e.Ellipsoid,C=new e.Cartesian3,b={min:void 0,max:void 0};const w=new e.Cartesian3,y=new e.Cartesian3,h=new e.Cartesian3,k=new e.Cartesian3,m=new e.Cartesian3;return s((function(s,i){const o=new Uint16Array(s.positions),c=new Uint16Array(s.widths),A=new Uint32Array(s.counts),g=new Uint16Array(s.batchIds);!function(t){t=new Float64Array(t);let a=0;b.min=t[a++],b.max=t[a++],e.Rectangle.unpack(t,a,d),a+=e.Rectangle.packedLength,e.Ellipsoid.unpack(t,a,l),a+=e.Ellipsoid.packedLength,e.Cartesian3.unpack(t,a,C)}(s.packedBuffer);const x=l,D=C,E=function(t,r,s,i,o){const c=t.length/3,d=t.subarray(0,c),l=t.subarray(c,2*c),C=t.subarray(2*c,3*c);a.AttributeCompression.zigZagDeltaDecode(d,l,C);const b=new Float64Array(t.length);for(let t=0;t<c;++t){const a=d[t],c=l[t],w=C[t],y=n.CesiumMath.lerp(r.west,r.east,a/u),h=n.CesiumMath.lerp(r.south,r.north,c/u),k=n.CesiumMath.lerp(s,i,w/u),m=e.Cartographic.fromRadians(y,h,k,f),A=o.cartographicToCartesian(m,p);e.Cartesian3.pack(A,b,3*t)}return b}(o,d,b.min,b.max,x),I=E.length/3,P=4*I-4,U=new Float32Array(3*P),R=new Float32Array(3*P),T=new Float32Array(3*P),F=new Float32Array(2*P),N=new Uint16Array(P);let M,L=0,S=0,_=0,v=0,G=A.length;for(M=0;M<G;++M){const t=A[M],a=c[M],n=g[M];for(let r=0;r<t;++r){let s;if(0===r){const t=e.Cartesian3.unpack(E,3*v,w),a=e.Cartesian3.unpack(E,3*(v+1),y);s=e.Cartesian3.subtract(t,a,h),e.Cartesian3.add(t,s,s)}else s=e.Cartesian3.unpack(E,3*(v+r-1),h);const i=e.Cartesian3.unpack(E,3*(v+r),k);let o;if(r===t-1){const a=e.Cartesian3.unpack(E,3*(v+t-1),w),n=e.Cartesian3.unpack(E,3*(v+t-2),y);o=e.Cartesian3.subtract(a,n,m),e.Cartesian3.add(a,o,o)}else o=e.Cartesian3.unpack(E,3*(v+r+1),m);e.Cartesian3.subtract(s,D,s),e.Cartesian3.subtract(i,D,i),e.Cartesian3.subtract(o,D,o);const c=r===t-1?2:4;for(let t=0===r?2:0;t<c;++t){e.Cartesian3.pack(i,U,L),e.Cartesian3.pack(s,R,L),e.Cartesian3.pack(o,T,L),L+=3;const r=t-2<0?-1:1;F[S++]=t%2*2-1,F[S++]=r*a,N[_++]=n}}v+=t}const W=r.IndexDatatype.createTypedArray(P,6*I-6);let B=0,O=0;for(G=I-1,M=0;M<G;++M)W[O++]=B,W[O++]=B+2,W[O++]=B+1,W[O++]=B+1,W[O++]=B+2,W[O++]=B+3,B+=4;i.push(U.buffer,R.buffer,T.buffer),i.push(F.buffer,N.buffer,W.buffer);let z={indexDatatype:2===W.BYTES_PER_ELEMENT?r.IndexDatatype.UNSIGNED_SHORT:r.IndexDatatype.UNSIGNED_INT,currentPositions:U.buffer,previousPositions:R.buffer,nextPositions:T.buffer,expandAndWidth:F.buffer,batchIds:N.buffer,indices:W.buffer};if(s.keepDecodedPositions){const e=function(e){const t=e.length,a=new Uint32Array(t+1);let n=0;for(let r=0;r<t;++r)a[r]=n,n+=e[r];return a[t]=n,a}(A);i.push(E.buffer,e.buffer),z=t.combine(z,{decodedPositions:E.buffer,decodedPositionOffsets:e.buffer})}return z}))}));
+/**
+ * @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 {
+  createTaskProcessorWorker_default
+} from "./chunk-A4JVFBQ3.js";
+import {
+  AttributeCompression_default
+} from "./chunk-O5AMBQ36.js";
+import {
+  IndexDatatype_default
+} from "./chunk-RW6LU2CJ.js";
+import {
+  combine_default
+} from "./chunk-QJ3DFBH3.js";
+import {
+  Rectangle_default
+} from "./chunk-DUHWWBQQ.js";
+import "./chunk-LLUNNUJV.js";
+import {
+  Cartesian3_default,
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-PCJWUS4M.js";
+import {
+  Math_default
+} from "./chunk-N3JIFFX2.js";
+import "./chunk-AHKEZ2OE.js";
+import "./chunk-ABADGKYE.js";
+import "./chunk-WXTV4ATB.js";
+import "./chunk-4MFFIWUA.js";
+import "./chunk-6BTKZDRG.js";
+
+// packages/engine/Source/Core/decodeVectorPolylinePositions.js
+var maxShort = 32767;
+var scratchBVCartographic = new Cartographic_default();
+var scratchEncodedPosition = new Cartesian3_default();
+function decodeVectorPolylinePositions(positions, rectangle, minimumHeight, maximumHeight, ellipsoid) {
+  const positionsLength = positions.length / 3;
+  const uBuffer = positions.subarray(0, positionsLength);
+  const vBuffer = positions.subarray(positionsLength, 2 * positionsLength);
+  const heightBuffer = positions.subarray(
+    2 * positionsLength,
+    3 * positionsLength
+  );
+  AttributeCompression_default.zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer);
+  const decoded = new Float64Array(positions.length);
+  for (let i = 0; i < positionsLength; ++i) {
+    const u = uBuffer[i];
+    const v = vBuffer[i];
+    const h = heightBuffer[i];
+    const lon = Math_default.lerp(rectangle.west, rectangle.east, u / maxShort);
+    const lat = Math_default.lerp(rectangle.south, rectangle.north, v / maxShort);
+    const alt = Math_default.lerp(minimumHeight, maximumHeight, h / maxShort);
+    const cartographic = Cartographic_default.fromRadians(
+      lon,
+      lat,
+      alt,
+      scratchBVCartographic
+    );
+    const decodedPosition = ellipsoid.cartographicToCartesian(
+      cartographic,
+      scratchEncodedPosition
+    );
+    Cartesian3_default.pack(decodedPosition, decoded, i * 3);
+  }
+  return decoded;
+}
+var decodeVectorPolylinePositions_default = decodeVectorPolylinePositions;
+
+// packages/engine/Source/Workers/createVectorTilePolylines.js
+var scratchRectangle = new Rectangle_default();
+var scratchEllipsoid = new Ellipsoid_default();
+var scratchCenter = new Cartesian3_default();
+var scratchMinMaxHeights = {
+  min: void 0,
+  max: void 0
+};
+function unpackBuffer(packedBuffer) {
+  packedBuffer = new Float64Array(packedBuffer);
+  let offset = 0;
+  scratchMinMaxHeights.min = packedBuffer[offset++];
+  scratchMinMaxHeights.max = packedBuffer[offset++];
+  Rectangle_default.unpack(packedBuffer, offset, scratchRectangle);
+  offset += Rectangle_default.packedLength;
+  Ellipsoid_default.unpack(packedBuffer, offset, scratchEllipsoid);
+  offset += Ellipsoid_default.packedLength;
+  Cartesian3_default.unpack(packedBuffer, offset, scratchCenter);
+}
+function getPositionOffsets(counts) {
+  const countsLength = counts.length;
+  const positionOffsets = new Uint32Array(countsLength + 1);
+  let offset = 0;
+  for (let i = 0; i < countsLength; ++i) {
+    positionOffsets[i] = offset;
+    offset += counts[i];
+  }
+  positionOffsets[countsLength] = offset;
+  return positionOffsets;
+}
+var scratchP0 = new Cartesian3_default();
+var scratchP1 = new Cartesian3_default();
+var scratchPrev = new Cartesian3_default();
+var scratchCur = new Cartesian3_default();
+var scratchNext = new Cartesian3_default();
+function createVectorTilePolylines(parameters, transferableObjects) {
+  const encodedPositions = new Uint16Array(parameters.positions);
+  const widths = new Uint16Array(parameters.widths);
+  const counts = new Uint32Array(parameters.counts);
+  const batchIds = new Uint16Array(parameters.batchIds);
+  unpackBuffer(parameters.packedBuffer);
+  const rectangle = scratchRectangle;
+  const ellipsoid = scratchEllipsoid;
+  const center = scratchCenter;
+  const minimumHeight = scratchMinMaxHeights.min;
+  const maximumHeight = scratchMinMaxHeights.max;
+  const positions = decodeVectorPolylinePositions_default(
+    encodedPositions,
+    rectangle,
+    minimumHeight,
+    maximumHeight,
+    ellipsoid
+  );
+  const positionsLength = positions.length / 3;
+  const size = positionsLength * 4 - 4;
+  const curPositions = new Float32Array(size * 3);
+  const prevPositions = new Float32Array(size * 3);
+  const nextPositions = new Float32Array(size * 3);
+  const expandAndWidth = new Float32Array(size * 2);
+  const vertexBatchIds = new Uint16Array(size);
+  let positionIndex = 0;
+  let expandAndWidthIndex = 0;
+  let batchIdIndex = 0;
+  let i;
+  let offset = 0;
+  let length = counts.length;
+  for (i = 0; i < length; ++i) {
+    const count = counts[i];
+    const width = widths[i];
+    const batchId = batchIds[i];
+    for (let j = 0; j < count; ++j) {
+      let previous;
+      if (j === 0) {
+        const p0 = Cartesian3_default.unpack(positions, offset * 3, scratchP0);
+        const p1 = Cartesian3_default.unpack(positions, (offset + 1) * 3, scratchP1);
+        previous = Cartesian3_default.subtract(p0, p1, scratchPrev);
+        Cartesian3_default.add(p0, previous, previous);
+      } else {
+        previous = Cartesian3_default.unpack(
+          positions,
+          (offset + j - 1) * 3,
+          scratchPrev
+        );
+      }
+      const current = Cartesian3_default.unpack(
+        positions,
+        (offset + j) * 3,
+        scratchCur
+      );
+      let next;
+      if (j === count - 1) {
+        const p2 = Cartesian3_default.unpack(
+          positions,
+          (offset + count - 1) * 3,
+          scratchP0
+        );
+        const p3 = Cartesian3_default.unpack(
+          positions,
+          (offset + count - 2) * 3,
+          scratchP1
+        );
+        next = Cartesian3_default.subtract(p2, p3, scratchNext);
+        Cartesian3_default.add(p2, next, next);
+      } else {
+        next = Cartesian3_default.unpack(positions, (offset + j + 1) * 3, scratchNext);
+      }
+      Cartesian3_default.subtract(previous, center, previous);
+      Cartesian3_default.subtract(current, center, current);
+      Cartesian3_default.subtract(next, center, next);
+      const startK = j === 0 ? 2 : 0;
+      const endK = j === count - 1 ? 2 : 4;
+      for (let k = startK; k < endK; ++k) {
+        Cartesian3_default.pack(current, curPositions, positionIndex);
+        Cartesian3_default.pack(previous, prevPositions, positionIndex);
+        Cartesian3_default.pack(next, nextPositions, positionIndex);
+        positionIndex += 3;
+        const direction = k - 2 < 0 ? -1 : 1;
+        expandAndWidth[expandAndWidthIndex++] = 2 * (k % 2) - 1;
+        expandAndWidth[expandAndWidthIndex++] = direction * width;
+        vertexBatchIds[batchIdIndex++] = batchId;
+      }
+    }
+    offset += count;
+  }
+  const indices = IndexDatatype_default.createTypedArray(size, positionsLength * 6 - 6);
+  let index = 0;
+  let indicesIndex = 0;
+  length = positionsLength - 1;
+  for (i = 0; i < length; ++i) {
+    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;
+  }
+  transferableObjects.push(
+    curPositions.buffer,
+    prevPositions.buffer,
+    nextPositions.buffer
+  );
+  transferableObjects.push(
+    expandAndWidth.buffer,
+    vertexBatchIds.buffer,
+    indices.buffer
+  );
+  let results = {
+    indexDatatype: indices.BYTES_PER_ELEMENT === 2 ? IndexDatatype_default.UNSIGNED_SHORT : IndexDatatype_default.UNSIGNED_INT,
+    currentPositions: curPositions.buffer,
+    previousPositions: prevPositions.buffer,
+    nextPositions: nextPositions.buffer,
+    expandAndWidth: expandAndWidth.buffer,
+    batchIds: vertexBatchIds.buffer,
+    indices: indices.buffer
+  };
+  if (parameters.keepDecodedPositions) {
+    const positionOffsets = getPositionOffsets(counts);
+    transferableObjects.push(positions.buffer, positionOffsets.buffer);
+    results = combine_default(results, {
+      decodedPositions: positions.buffer,
+      decodedPositionOffsets: positionOffsets.buffer
+    });
+  }
+  return results;
+}
+var createVectorTilePolylines_default = createTaskProcessorWorker_default(createVectorTilePolylines);
+export {
+  createVectorTilePolylines_default as default
+};