@vcmap/ui 5.0.0-rc.18 → 5.0.0-rc.20

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

@@ -1,25 +1,406 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.97.1
- *
- * 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.
- */
-define(["./AttributeCompression-7b0f288d","./Matrix2-eefef8eb","./Color-cc8c18b3","./defaultValue-0c475b81","./IndexDatatype-e713bfd2","./ComponentDatatype-0200bf8c","./OrientedBoundingBox-5193f9a2","./createTaskProcessorWorker","./RuntimeError-5baf5c66","./Transforms-d2e5867e","./_commonjsHelpers-bc29abbc","./combine-7533016d","./WebGLConstants-5b50ced1","./EllipsoidTangentPlane-c080fd1b","./AxisAlignedBoundingBox-d0c22774","./IntersectionTests-eb4db8e0","./Plane-b0299683"],(function(e,t,n,a,r,o,s,i,c,f,d,l,u,h,b,g,p){"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),b=new Uint32Array(i.batchTableColors),g=new Array(l.length),p=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=b[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=b[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,p,h),t.Cartesian3.subtract(u,p,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,g[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,g,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}}))}));
+define(['./AttributeCompression-b646d393', './Matrix3-315394f6', './Color-a84038cb', './defaultValue-0a909f67', './IndexDatatype-a55ceaa1', './Math-2dbd6b93', './OrientedBoundingBox-04920dc7', './Matrix2-13178034', './createTaskProcessorWorker', './ComponentDatatype-f7b11d02', './Check-666ab1a0', './WebGLConstants-a8cc3e8c', './Transforms-40229881', './combine-ca22a614', './RuntimeError-06c93819', './EllipsoidTangentPlane-214683dc', './AxisAlignedBoundingBox-ff186ccc', './IntersectionTests-f6e6bd8a', './Plane-900aa728'], (function (AttributeCompression, Matrix3, Color, defaultValue, IndexDatatype, Math$1, OrientedBoundingBox, Matrix2, createTaskProcessorWorker, ComponentDatatype, Check, WebGLConstants, Transforms, combine, RuntimeError, EllipsoidTangentPlane, AxisAlignedBoundingBox, IntersectionTests, Plane) { 'use strict';
+
+  const scratchCenter = new Matrix3.Cartesian3();
+  const scratchEllipsoid = new Matrix3.Ellipsoid();
+  const scratchRectangle = new Matrix2.Rectangle();
+  const scratchScalars = {
+    min: undefined,
+    max: undefined,
+    indexBytesPerElement: undefined,
+  };
+
+  function unpackBuffer(buffer) {
+    const packedBuffer = new Float64Array(buffer);
+
+    let offset = 0;
+    scratchScalars.indexBytesPerElement = packedBuffer[offset++];
+
+    scratchScalars.min = packedBuffer[offset++];
+    scratchScalars.max = packedBuffer[offset++];
+
+    Matrix3.Cartesian3.unpack(packedBuffer, offset, scratchCenter);
+    offset += Matrix3.Cartesian3.packedLength;
+
+    Matrix3.Ellipsoid.unpack(packedBuffer, offset, scratchEllipsoid);
+    offset += Matrix3.Ellipsoid.packedLength;
+
+    Matrix2.Rectangle.unpack(packedBuffer, offset, scratchRectangle);
+  }
+
+  function packedBatchedIndicesLength(batchedIndices) {
+    const length = batchedIndices.length;
+    let count = 0;
+    for (let i = 0; i < length; ++i) {
+      count += Color.Color.packedLength + 3 + batchedIndices[i].batchIds.length;
+    }
+    return count;
+  }
+
+  function packBuffer(indexDatatype, boundingVolumes, batchedIndices) {
+    const numBVs = boundingVolumes.length;
+    const length =
+      1 +
+      1 +
+      numBVs * OrientedBoundingBox.OrientedBoundingBox.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.OrientedBoundingBox.pack(boundingVolumes[i], packedBuffer, offset);
+      offset += OrientedBoundingBox.OrientedBoundingBox.packedLength;
+    }
+
+    const indicesLength = batchedIndices.length;
+    packedBuffer[offset++] = indicesLength;
+
+    for (let j = 0; j < indicesLength; ++j) {
+      const batchedIndex = batchedIndices[j];
+
+      Color.Color.pack(batchedIndex.color, packedBuffer, offset);
+      offset += Color.Color.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;
+  }
+
+  const maxShort = 32767;
+
+  const scratchEncodedPosition = new Matrix3.Cartesian3();
+  const scratchNormal = new Matrix3.Cartesian3();
+  const scratchScaledNormal = new Matrix3.Cartesian3();
+  const scratchMinHeightPosition = new Matrix3.Cartesian3();
+  const scratchMaxHeightPosition = new Matrix3.Cartesian3();
+  const scratchBVCartographic = new Matrix3.Cartographic();
+  const scratchBVRectangle = new Matrix2.Rectangle();
+
+  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 (defaultValue.defined(minimumHeights) && defaultValue.defined(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.AttributeCompression.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$1.CesiumMath.lerp(rectangle.west, rectangle.east, u / maxShort);
+      const y = Math$1.CesiumMath.lerp(rectangle.south, rectangle.north, v / maxShort);
+
+      const cart = Matrix3.Cartographic.fromRadians(x, y, 0.0, scratchBVCartographic);
+      const decodedPosition = ellipsoid.cartographicToCartesian(
+        cart,
+        scratchEncodedPosition
+      );
+      Matrix3.Cartesian3.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 (!defaultValue.defined(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);
+      }
+    }
+
+    // get the offsets and counts for the positions and indices of each primitive
+    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.Color.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 (defaultValue.defined(minimumHeights) && defaultValue.defined(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 = Matrix3.Cartesian3.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 = Matrix3.Cartesian3.multiplyByScalar(
+          normal,
+          polygonMinimumHeight,
+          scratchScaledNormal
+        );
+        const minHeightPosition = Matrix3.Cartesian3.add(
+          position,
+          scaledNormal,
+          scratchMinHeightPosition
+        );
+
+        scaledNormal = Matrix3.Cartesian3.multiplyByScalar(
+          normal,
+          polygonMaximumHeight,
+          scaledNormal
+        );
+        const maxHeightPosition = Matrix3.Cartesian3.add(
+          position,
+          scaledNormal,
+          scratchMaxHeightPosition
+        );
+
+        Matrix3.Cartesian3.subtract(maxHeightPosition, center, maxHeightPosition);
+        Matrix3.Cartesian3.subtract(minHeightPosition, center, minHeightPosition);
+
+        Matrix3.Cartesian3.pack(maxHeightPosition, batchedPositions, positionIndex);
+        Matrix3.Cartesian3.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.OrientedBoundingBox.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;
+
+        // triangle on the top of the extruded polygon
+        batchedIndices[indicesIndex++] = i0 * 2 + positionOffset;
+        batchedIndices[indicesIndex++] = i1 * 2 + positionOffset;
+        batchedIndices[indicesIndex++] = i2 * 2 + positionOffset;
+
+        // triangle on the bottom of the extruded polygon
+        batchedIndices[indicesIndex++] = i2 * 2 + 1 + positionOffset;
+        batchedIndices[indicesIndex++] = i1 * 2 + 1 + positionOffset;
+        batchedIndices[indicesIndex++] = i0 * 2 + 1 + positionOffset;
+      }
+
+      // indices for the walls of the extruded polygon
+      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.IndexDatatype.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.IndexDatatype.UNSIGNED_SHORT
+        : IndexDatatype.IndexDatatype.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$1 = createTaskProcessorWorker(createVectorTilePolygons);
+
+  return createVectorTilePolygons$1;
+
+}));