@pggis/pg-sdk 3.3.10 → 3.5.0

package/dist/resources/Workers/createWallOutlineGeometry.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.115
+ * Version 1.132
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -23,316 +23,4 @@
  * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
  */
 
-import {
-  WallGeometryLibrary_default
-} from "./chunk-4DO5W5XZ.js";
-import "./chunk-KKCR2YOP.js";
-import "./chunk-F4HFJMGM.js";
-import "./chunk-FZRIVR7Y.js";
-import "./chunk-SH5USDPI.js";
-import "./chunk-2FRVPMCS.js";
-import "./chunk-Y5UQJLYE.js";
-import {
-  IndexDatatype_default
-} from "./chunk-LPR3YNP2.js";
-import {
-  GeometryAttributes_default
-} from "./chunk-4H7PY4U5.js";
-import {
-  GeometryAttribute_default,
-  Geometry_default,
-  PrimitiveType_default
-} from "./chunk-7TC63SJW.js";
-import {
-  BoundingSphere_default
-} from "./chunk-FJKNFAKQ.js";
-import "./chunk-TTUZP4BO.js";
-import "./chunk-BG4UCVXN.js";
-import "./chunk-YJEBABKH.js";
-import {
-  ComponentDatatype_default
-} from "./chunk-PPH7OFP3.js";
-import {
-  Cartesian3_default,
-  Ellipsoid_default
-} from "./chunk-OGXZVPPM.js";
-import {
-  Math_default
-} from "./chunk-5QULIR53.js";
-import "./chunk-SOWMRMWA.js";
-import "./chunk-STW2DGFI.js";
-import {
-  defaultValue_default
-} from "./chunk-BBWDMCVU.js";
-import {
-  DeveloperError_default
-} from "./chunk-XGI5BXZY.js";
-import {
-  defined_default
-} from "./chunk-YWTJ2B4B.js";
-
-// packages/engine/Source/Core/WallOutlineGeometry.js
-var scratchCartesian3Position1 = new Cartesian3_default();
-var scratchCartesian3Position2 = new Cartesian3_default();
-function WallOutlineGeometry(options) {
-  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
-  const wallPositions = options.positions;
-  const maximumHeights = options.maximumHeights;
-  const minimumHeights = options.minimumHeights;
-  if (!defined_default(wallPositions)) {
-    throw new DeveloperError_default("options.positions is required.");
-  }
-  if (defined_default(maximumHeights) && maximumHeights.length !== wallPositions.length) {
-    throw new DeveloperError_default(
-      "options.positions and options.maximumHeights must have the same length."
-    );
-  }
-  if (defined_default(minimumHeights) && minimumHeights.length !== wallPositions.length) {
-    throw new DeveloperError_default(
-      "options.positions and options.minimumHeights must have the same length."
-    );
-  }
-  const granularity = defaultValue_default(
-    options.granularity,
-    Math_default.RADIANS_PER_DEGREE
-  );
-  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
-  this._positions = wallPositions;
-  this._minimumHeights = minimumHeights;
-  this._maximumHeights = maximumHeights;
-  this._granularity = granularity;
-  this._ellipsoid = Ellipsoid_default.clone(ellipsoid);
-  this._workerName = "createWallOutlineGeometry";
-  let numComponents = 1 + wallPositions.length * Cartesian3_default.packedLength + 2;
-  if (defined_default(minimumHeights)) {
-    numComponents += minimumHeights.length;
-  }
-  if (defined_default(maximumHeights)) {
-    numComponents += maximumHeights.length;
-  }
-  this.packedLength = numComponents + Ellipsoid_default.packedLength + 1;
-}
-WallOutlineGeometry.pack = function(value, array, startingIndex) {
-  if (!defined_default(value)) {
-    throw new DeveloperError_default("value is required");
-  }
-  if (!defined_default(array)) {
-    throw new DeveloperError_default("array is required");
-  }
-  startingIndex = defaultValue_default(startingIndex, 0);
-  let i;
-  const positions = value._positions;
-  let length = positions.length;
-  array[startingIndex++] = length;
-  for (i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
-    Cartesian3_default.pack(positions[i], array, startingIndex);
-  }
-  const minimumHeights = value._minimumHeights;
-  length = defined_default(minimumHeights) ? minimumHeights.length : 0;
-  array[startingIndex++] = length;
-  if (defined_default(minimumHeights)) {
-    for (i = 0; i < length; ++i) {
-      array[startingIndex++] = minimumHeights[i];
-    }
-  }
-  const maximumHeights = value._maximumHeights;
-  length = defined_default(maximumHeights) ? maximumHeights.length : 0;
-  array[startingIndex++] = length;
-  if (defined_default(maximumHeights)) {
-    for (i = 0; i < length; ++i) {
-      array[startingIndex++] = maximumHeights[i];
-    }
-  }
-  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
-  startingIndex += Ellipsoid_default.packedLength;
-  array[startingIndex] = value._granularity;
-  return array;
-};
-var scratchEllipsoid = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
-var scratchOptions = {
-  positions: void 0,
-  minimumHeights: void 0,
-  maximumHeights: void 0,
-  ellipsoid: scratchEllipsoid,
-  granularity: void 0
-};
-WallOutlineGeometry.unpack = function(array, startingIndex, result) {
-  if (!defined_default(array)) {
-    throw new DeveloperError_default("array is required");
-  }
-  startingIndex = defaultValue_default(startingIndex, 0);
-  let i;
-  let length = array[startingIndex++];
-  const positions = new Array(length);
-  for (i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
-    positions[i] = Cartesian3_default.unpack(array, startingIndex);
-  }
-  length = array[startingIndex++];
-  let minimumHeights;
-  if (length > 0) {
-    minimumHeights = new Array(length);
-    for (i = 0; i < length; ++i) {
-      minimumHeights[i] = array[startingIndex++];
-    }
-  }
-  length = array[startingIndex++];
-  let maximumHeights;
-  if (length > 0) {
-    maximumHeights = new Array(length);
-    for (i = 0; i < length; ++i) {
-      maximumHeights[i] = array[startingIndex++];
-    }
-  }
-  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
-  startingIndex += Ellipsoid_default.packedLength;
-  const granularity = array[startingIndex];
-  if (!defined_default(result)) {
-    scratchOptions.positions = positions;
-    scratchOptions.minimumHeights = minimumHeights;
-    scratchOptions.maximumHeights = maximumHeights;
-    scratchOptions.granularity = granularity;
-    return new WallOutlineGeometry(scratchOptions);
-  }
-  result._positions = positions;
-  result._minimumHeights = minimumHeights;
-  result._maximumHeights = maximumHeights;
-  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
-  result._granularity = granularity;
-  return result;
-};
-WallOutlineGeometry.fromConstantHeights = function(options) {
-  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
-  const positions = options.positions;
-  if (!defined_default(positions)) {
-    throw new DeveloperError_default("options.positions is required.");
-  }
-  let minHeights;
-  let maxHeights;
-  const min = options.minimumHeight;
-  const max = options.maximumHeight;
-  const doMin = defined_default(min);
-  const doMax = defined_default(max);
-  if (doMin || doMax) {
-    const length = positions.length;
-    minHeights = doMin ? new Array(length) : void 0;
-    maxHeights = doMax ? new Array(length) : void 0;
-    for (let i = 0; i < length; ++i) {
-      if (doMin) {
-        minHeights[i] = min;
-      }
-      if (doMax) {
-        maxHeights[i] = max;
-      }
-    }
-  }
-  const newOptions = {
-    positions,
-    maximumHeights: maxHeights,
-    minimumHeights: minHeights,
-    ellipsoid: options.ellipsoid
-  };
-  return new WallOutlineGeometry(newOptions);
-};
-WallOutlineGeometry.createGeometry = function(wallGeometry) {
-  const wallPositions = wallGeometry._positions;
-  const minimumHeights = wallGeometry._minimumHeights;
-  const maximumHeights = wallGeometry._maximumHeights;
-  const granularity = wallGeometry._granularity;
-  const ellipsoid = wallGeometry._ellipsoid;
-  const pos = WallGeometryLibrary_default.computePositions(
-    ellipsoid,
-    wallPositions,
-    maximumHeights,
-    minimumHeights,
-    granularity,
-    false
-  );
-  if (!defined_default(pos)) {
-    return;
-  }
-  const bottomPositions = pos.bottomPositions;
-  const topPositions = pos.topPositions;
-  let length = topPositions.length;
-  let size = length * 2;
-  const positions = new Float64Array(size);
-  let positionIndex = 0;
-  length /= 3;
-  let i;
-  for (i = 0; i < length; ++i) {
-    const i3 = i * 3;
-    const topPosition = Cartesian3_default.fromArray(
-      topPositions,
-      i3,
-      scratchCartesian3Position1
-    );
-    const bottomPosition = Cartesian3_default.fromArray(
-      bottomPositions,
-      i3,
-      scratchCartesian3Position2
-    );
-    positions[positionIndex++] = bottomPosition.x;
-    positions[positionIndex++] = bottomPosition.y;
-    positions[positionIndex++] = bottomPosition.z;
-    positions[positionIndex++] = topPosition.x;
-    positions[positionIndex++] = topPosition.y;
-    positions[positionIndex++] = topPosition.z;
-  }
-  const attributes = new GeometryAttributes_default({
-    position: new GeometryAttribute_default({
-      componentDatatype: ComponentDatatype_default.DOUBLE,
-      componentsPerAttribute: 3,
-      values: positions
-    })
-  });
-  const numVertices = size / 3;
-  size = 2 * numVertices - 4 + numVertices;
-  const indices = IndexDatatype_default.createTypedArray(numVertices, size);
-  let edgeIndex = 0;
-  for (i = 0; i < numVertices - 2; i += 2) {
-    const LL = i;
-    const LR = i + 2;
-    const pl = Cartesian3_default.fromArray(
-      positions,
-      LL * 3,
-      scratchCartesian3Position1
-    );
-    const pr = Cartesian3_default.fromArray(
-      positions,
-      LR * 3,
-      scratchCartesian3Position2
-    );
-    if (Cartesian3_default.equalsEpsilon(pl, pr, Math_default.EPSILON10)) {
-      continue;
-    }
-    const UL = i + 1;
-    const UR = i + 3;
-    indices[edgeIndex++] = UL;
-    indices[edgeIndex++] = LL;
-    indices[edgeIndex++] = UL;
-    indices[edgeIndex++] = UR;
-    indices[edgeIndex++] = LL;
-    indices[edgeIndex++] = LR;
-  }
-  indices[edgeIndex++] = numVertices - 2;
-  indices[edgeIndex++] = numVertices - 1;
-  return new Geometry_default({
-    attributes,
-    indices,
-    primitiveType: PrimitiveType_default.LINES,
-    boundingSphere: new BoundingSphere_default.fromVertices(positions)
-  });
-};
-var WallOutlineGeometry_default = WallOutlineGeometry;
-
-// packages/engine/Source/Workers/createWallOutlineGeometry.js
-function createWallOutlineGeometry(wallGeometry, offset) {
-  if (defined_default(offset)) {
-    wallGeometry = WallOutlineGeometry_default.unpack(wallGeometry, offset);
-  }
-  wallGeometry._ellipsoid = Ellipsoid_default.clone(wallGeometry._ellipsoid);
-  return WallOutlineGeometry_default.createGeometry(wallGeometry);
-}
-var createWallOutlineGeometry_default = createWallOutlineGeometry;
-export {
-  createWallOutlineGeometry_default as default
-};
+import{a as z}from"./chunk-NB3ML6JO.js";import"./chunk-XRL4AVS5.js";import"./chunk-U4IEOH5K.js";import"./chunk-3W4GT7KQ.js";import"./chunk-G5AGHVVC.js";import"./chunk-DMEY62ID.js";import"./chunk-HTFSEEMT.js";import{a as W}from"./chunk-OFUUQVMR.js";import{a as N}from"./chunk-A56XVLQR.js";import{b as R,c as S,d as M}from"./chunk-RCV6KWXS.js";import{d as D}from"./chunk-4IW2T6GF.js";import"./chunk-PSPPBZWI.js";import{a as q}from"./chunk-AU7IKHOH.js";import{a as p,d as l,f as O}from"./chunk-64RSHJUE.js";import{a as b}from"./chunk-3SSKC3VN.js";import"./chunk-OSW76XDF.js";import"./chunk-ED5JPB3S.js";import{a as H}from"./chunk-LEYMRMBK.js";import{e as m}from"./chunk-VTAIKJXX.js";var B=new p,U=new p;function _(i){i=i??O.EMPTY_OBJECT;let t=i.positions,e=i.maximumHeights,o=i.minimumHeights;if(!m(t))throw new H("options.positions is required.");if(m(e)&&e.length!==t.length)throw new H("options.positions and options.maximumHeights must have the same length.");if(m(o)&&o.length!==t.length)throw new H("options.positions and options.minimumHeights must have the same length.");let s=i.granularity??b.RADIANS_PER_DEGREE,r=i.ellipsoid??l.default;this._positions=t,this._minimumHeights=o,this._maximumHeights=e,this._granularity=s,this._ellipsoid=l.clone(r),this._workerName="createWallOutlineGeometry";let n=1+t.length*p.packedLength+2;m(o)&&(n+=o.length),m(e)&&(n+=e.length),this.packedLength=n+l.packedLength+1}_.pack=function(i,t,e){if(!m(i))throw new H("value is required");if(!m(t))throw new H("array is required");e=e??0;let o,s=i._positions,r=s.length;for(t[e++]=r,o=0;o<r;++o,e+=p.packedLength)p.pack(s[o],t,e);let n=i._minimumHeights;if(r=m(n)?n.length:0,t[e++]=r,m(n))for(o=0;o<r;++o)t[e++]=n[o];let c=i._maximumHeights;if(r=m(c)?c.length:0,t[e++]=r,m(c))for(o=0;o<r;++o)t[e++]=c[o];return l.pack(i._ellipsoid,t,e),e+=l.packedLength,t[e]=i._granularity,t};var G=l.clone(l.UNIT_SPHERE),L={positions:void 0,minimumHeights:void 0,maximumHeights:void 0,ellipsoid:G,granularity:void 0};_.unpack=function(i,t,e){if(!m(i))throw new H("array is required");t=t??0;let o,s=i[t++],r=new Array(s);for(o=0;o<s;++o,t+=p.packedLength)r[o]=p.unpack(i,t);s=i[t++];let n;if(s>0)for(n=new Array(s),o=0;o<s;++o)n[o]=i[t++];s=i[t++];let c;if(s>0)for(c=new Array(s),o=0;o<s;++o)c[o]=i[t++];let w=l.unpack(i,t,G);t+=l.packedLength;let u=i[t];return m(e)?(e._positions=r,e._minimumHeights=n,e._maximumHeights=c,e._ellipsoid=l.clone(w,e._ellipsoid),e._granularity=u,e):(L.positions=r,L.minimumHeights=n,L.maximumHeights=c,L.granularity=u,new _(L))};_.fromConstantHeights=function(i){i=i??O.EMPTY_OBJECT;let t=i.positions;if(!m(t))throw new H("options.positions is required.");let e,o,s=i.minimumHeight,r=i.maximumHeight,n=m(s),c=m(r);if(n||c){let u=t.length;e=n?new Array(u):void 0,o=c?new Array(u):void 0;for(let g=0;g<u;++g)n&&(e[g]=s),c&&(o[g]=r)}let w={positions:t,maximumHeights:o,minimumHeights:e,ellipsoid:i.ellipsoid};return new _(w)};_.createGeometry=function(i){let t=i._positions,e=i._minimumHeights,o=i._maximumHeights,s=i._granularity,r=i._ellipsoid,n=z.computePositions(r,t,o,e,s,!1);if(!m(n))return;let c=n.bottomPositions,w=n.topPositions,u=w.length,g=u*2,f=new Float64Array(g),E=0;u/=3;let h;for(h=0;h<u;++h){let y=h*3,A=p.fromArray(w,y,B),k=p.fromArray(c,y,U);f[E++]=k.x,f[E++]=k.y,f[E++]=k.z,f[E++]=A.x,f[E++]=A.y,f[E++]=A.z}let v=new N({position:new M({componentDatatype:q.DOUBLE,componentsPerAttribute:3,values:f})}),P=g/3;g=2*P-4+P;let a=W.createTypedArray(P,g),d=0;for(h=0;h<P-2;h+=2){let y=h,A=h+2,k=p.fromArray(f,y*3,B),x=p.fromArray(f,A*3,U);if(p.equalsEpsilon(k,x,b.EPSILON10))continue;let T=h+1,F=h+3;a[d++]=T,a[d++]=y,a[d++]=T,a[d++]=F,a[d++]=y,a[d++]=A}return a[d++]=P-2,a[d++]=P-1,new S({attributes:v,indices:a,primitiveType:R.LINES,boundingSphere:new D.fromVertices(f)})};var C=_;function J(i,t){return m(t)&&(i=C.unpack(i,t)),i._ellipsoid=l.clone(i._ellipsoid),C.createGeometry(i)}var pi=J;export{pi as default};

package/dist/resources/Workers/decodeDraco.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.115
+ * Version 1.132
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -23,347 +23,4 @@
  * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
  */
 
-import {
-  require_draco_decoder_nodejs
-} from "./chunk-GATZHF3K.js";
-import {
-  createTaskProcessorWorker_default
-} from "./chunk-3VAZEH7M.js";
-import {
-  IndexDatatype_default
-} from "./chunk-LPR3YNP2.js";
-import {
-  ComponentDatatype_default
-} from "./chunk-PPH7OFP3.js";
-import "./chunk-5QULIR53.js";
-import "./chunk-SOWMRMWA.js";
-import {
-  RuntimeError_default
-} from "./chunk-STW2DGFI.js";
-import "./chunk-BBWDMCVU.js";
-import "./chunk-XGI5BXZY.js";
-import {
-  __toESM,
-  defined_default
-} from "./chunk-YWTJ2B4B.js";
-
-// packages/engine/Source/Workers/decodeDraco.js
-var import_draco_decoder_nodejs = __toESM(require_draco_decoder_nodejs(), 1);
-var draco;
-function decodeIndexArray(dracoGeometry, dracoDecoder) {
-  const numPoints = dracoGeometry.num_points();
-  const numFaces = dracoGeometry.num_faces();
-  const faceIndices = new draco.DracoInt32Array();
-  const numIndices = numFaces * 3;
-  const indexArray = IndexDatatype_default.createTypedArray(numPoints, numIndices);
-  let offset = 0;
-  for (let i = 0; i < numFaces; ++i) {
-    dracoDecoder.GetFaceFromMesh(dracoGeometry, i, faceIndices);
-    indexArray[offset + 0] = faceIndices.GetValue(0);
-    indexArray[offset + 1] = faceIndices.GetValue(1);
-    indexArray[offset + 2] = faceIndices.GetValue(2);
-    offset += 3;
-  }
-  draco.destroy(faceIndices);
-  return {
-    typedArray: indexArray,
-    numberOfIndices: numIndices
-  };
-}
-function decodeQuantizedDracoTypedArray(dracoGeometry, dracoDecoder, dracoAttribute, quantization, vertexArrayLength) {
-  let vertexArray;
-  let attributeData;
-  if (quantization.quantizationBits <= 8) {
-    attributeData = new draco.DracoUInt8Array();
-    vertexArray = new Uint8Array(vertexArrayLength);
-    dracoDecoder.GetAttributeUInt8ForAllPoints(
-      dracoGeometry,
-      dracoAttribute,
-      attributeData
-    );
-  } else if (quantization.quantizationBits <= 16) {
-    attributeData = new draco.DracoUInt16Array();
-    vertexArray = new Uint16Array(vertexArrayLength);
-    dracoDecoder.GetAttributeUInt16ForAllPoints(
-      dracoGeometry,
-      dracoAttribute,
-      attributeData
-    );
-  } else {
-    attributeData = new draco.DracoFloat32Array();
-    vertexArray = new Float32Array(vertexArrayLength);
-    dracoDecoder.GetAttributeFloatForAllPoints(
-      dracoGeometry,
-      dracoAttribute,
-      attributeData
-    );
-  }
-  for (let i = 0; i < vertexArrayLength; ++i) {
-    vertexArray[i] = attributeData.GetValue(i);
-  }
-  draco.destroy(attributeData);
-  return vertexArray;
-}
-function decodeDracoTypedArray(dracoGeometry, dracoDecoder, dracoAttribute, vertexArrayLength) {
-  let vertexArray;
-  let attributeData;
-  switch (dracoAttribute.data_type()) {
-    case 1:
-    case 11:
-      attributeData = new draco.DracoInt8Array();
-      vertexArray = new Int8Array(vertexArrayLength);
-      dracoDecoder.GetAttributeInt8ForAllPoints(
-        dracoGeometry,
-        dracoAttribute,
-        attributeData
-      );
-      break;
-    case 2:
-      attributeData = new draco.DracoUInt8Array();
-      vertexArray = new Uint8Array(vertexArrayLength);
-      dracoDecoder.GetAttributeUInt8ForAllPoints(
-        dracoGeometry,
-        dracoAttribute,
-        attributeData
-      );
-      break;
-    case 3:
-      attributeData = new draco.DracoInt16Array();
-      vertexArray = new Int16Array(vertexArrayLength);
-      dracoDecoder.GetAttributeInt16ForAllPoints(
-        dracoGeometry,
-        dracoAttribute,
-        attributeData
-      );
-      break;
-    case 4:
-      attributeData = new draco.DracoUInt16Array();
-      vertexArray = new Uint16Array(vertexArrayLength);
-      dracoDecoder.GetAttributeUInt16ForAllPoints(
-        dracoGeometry,
-        dracoAttribute,
-        attributeData
-      );
-      break;
-    case 5:
-    case 7:
-      attributeData = new draco.DracoInt32Array();
-      vertexArray = new Int32Array(vertexArrayLength);
-      dracoDecoder.GetAttributeInt32ForAllPoints(
-        dracoGeometry,
-        dracoAttribute,
-        attributeData
-      );
-      break;
-    case 6:
-    case 8:
-      attributeData = new draco.DracoUInt32Array();
-      vertexArray = new Uint32Array(vertexArrayLength);
-      dracoDecoder.GetAttributeUInt32ForAllPoints(
-        dracoGeometry,
-        dracoAttribute,
-        attributeData
-      );
-      break;
-    case 9:
-    case 10:
-      attributeData = new draco.DracoFloat32Array();
-      vertexArray = new Float32Array(vertexArrayLength);
-      dracoDecoder.GetAttributeFloatForAllPoints(
-        dracoGeometry,
-        dracoAttribute,
-        attributeData
-      );
-      break;
-  }
-  for (let i = 0; i < vertexArrayLength; ++i) {
-    vertexArray[i] = attributeData.GetValue(i);
-  }
-  draco.destroy(attributeData);
-  return vertexArray;
-}
-function decodeAttribute(dracoGeometry, dracoDecoder, dracoAttribute) {
-  const numPoints = dracoGeometry.num_points();
-  const numComponents = dracoAttribute.num_components();
-  let quantization;
-  let transform = new draco.AttributeQuantizationTransform();
-  if (transform.InitFromAttribute(dracoAttribute)) {
-    const minValues = new Array(numComponents);
-    for (let i = 0; i < numComponents; ++i) {
-      minValues[i] = transform.min_value(i);
-    }
-    quantization = {
-      quantizationBits: transform.quantization_bits(),
-      minValues,
-      range: transform.range(),
-      octEncoded: false
-    };
-  }
-  draco.destroy(transform);
-  transform = new draco.AttributeOctahedronTransform();
-  if (transform.InitFromAttribute(dracoAttribute)) {
-    quantization = {
-      quantizationBits: transform.quantization_bits(),
-      octEncoded: true
-    };
-  }
-  draco.destroy(transform);
-  const vertexArrayLength = numPoints * numComponents;
-  let vertexArray;
-  if (defined_default(quantization)) {
-    vertexArray = decodeQuantizedDracoTypedArray(
-      dracoGeometry,
-      dracoDecoder,
-      dracoAttribute,
-      quantization,
-      vertexArrayLength
-    );
-  } else {
-    vertexArray = decodeDracoTypedArray(
-      dracoGeometry,
-      dracoDecoder,
-      dracoAttribute,
-      vertexArrayLength
-    );
-  }
-  const componentDatatype = ComponentDatatype_default.fromTypedArray(vertexArray);
-  return {
-    array: vertexArray,
-    data: {
-      componentsPerAttribute: numComponents,
-      componentDatatype,
-      byteOffset: dracoAttribute.byte_offset(),
-      byteStride: ComponentDatatype_default.getSizeInBytes(componentDatatype) * numComponents,
-      normalized: dracoAttribute.normalized(),
-      quantization
-    }
-  };
-}
-function decodePointCloud(parameters) {
-  const dracoDecoder = new draco.Decoder();
-  if (parameters.dequantizeInShader) {
-    dracoDecoder.SkipAttributeTransform(draco.POSITION);
-    dracoDecoder.SkipAttributeTransform(draco.NORMAL);
-  }
-  const buffer = new draco.DecoderBuffer();
-  buffer.Init(parameters.buffer, parameters.buffer.length);
-  const geometryType = dracoDecoder.GetEncodedGeometryType(buffer);
-  if (geometryType !== draco.POINT_CLOUD) {
-    throw new RuntimeError_default("Draco geometry type must be POINT_CLOUD.");
-  }
-  const dracoPointCloud = new draco.PointCloud();
-  const decodingStatus = dracoDecoder.DecodeBufferToPointCloud(
-    buffer,
-    dracoPointCloud
-  );
-  if (!decodingStatus.ok() || dracoPointCloud.ptr === 0) {
-    throw new RuntimeError_default(
-      `Error decoding draco point cloud: ${decodingStatus.error_msg()}`
-    );
-  }
-  draco.destroy(buffer);
-  const result = {};
-  const properties = parameters.properties;
-  for (const propertyName in properties) {
-    if (properties.hasOwnProperty(propertyName)) {
-      let dracoAttribute;
-      if (propertyName === "POSITION" || propertyName === "NORMAL") {
-        const dracoAttributeId = dracoDecoder.GetAttributeId(
-          dracoPointCloud,
-          draco[propertyName]
-        );
-        dracoAttribute = dracoDecoder.GetAttribute(
-          dracoPointCloud,
-          dracoAttributeId
-        );
-      } else {
-        const attributeId = properties[propertyName];
-        dracoAttribute = dracoDecoder.GetAttributeByUniqueId(
-          dracoPointCloud,
-          attributeId
-        );
-      }
-      result[propertyName] = decodeAttribute(
-        dracoPointCloud,
-        dracoDecoder,
-        dracoAttribute
-      );
-    }
-  }
-  draco.destroy(dracoPointCloud);
-  draco.destroy(dracoDecoder);
-  return result;
-}
-function decodePrimitive(parameters) {
-  const dracoDecoder = new draco.Decoder();
-  const attributesToSkip = ["POSITION", "NORMAL", "COLOR", "TEX_COORD"];
-  if (parameters.dequantizeInShader) {
-    for (let i = 0; i < attributesToSkip.length; ++i) {
-      dracoDecoder.SkipAttributeTransform(draco[attributesToSkip[i]]);
-    }
-  }
-  const bufferView = parameters.bufferView;
-  const buffer = new draco.DecoderBuffer();
-  buffer.Init(parameters.array, bufferView.byteLength);
-  const geometryType = dracoDecoder.GetEncodedGeometryType(buffer);
-  if (geometryType !== draco.TRIANGULAR_MESH) {
-    throw new RuntimeError_default("Unsupported draco mesh geometry type.");
-  }
-  const dracoGeometry = new draco.Mesh();
-  const decodingStatus = dracoDecoder.DecodeBufferToMesh(buffer, dracoGeometry);
-  if (!decodingStatus.ok() || dracoGeometry.ptr === 0) {
-    throw new RuntimeError_default(
-      `Error decoding draco mesh geometry: ${decodingStatus.error_msg()}`
-    );
-  }
-  draco.destroy(buffer);
-  const attributeData = {};
-  const compressedAttributes = parameters.compressedAttributes;
-  for (const attributeName in compressedAttributes) {
-    if (compressedAttributes.hasOwnProperty(attributeName)) {
-      const compressedAttribute = compressedAttributes[attributeName];
-      const dracoAttribute = dracoDecoder.GetAttributeByUniqueId(
-        dracoGeometry,
-        compressedAttribute
-      );
-      attributeData[attributeName] = decodeAttribute(
-        dracoGeometry,
-        dracoDecoder,
-        dracoAttribute
-      );
-    }
-  }
-  const result = {
-    indexArray: decodeIndexArray(dracoGeometry, dracoDecoder),
-    attributeData
-  };
-  draco.destroy(dracoGeometry);
-  draco.destroy(dracoDecoder);
-  return result;
-}
-async function decode(parameters, transferableObjects) {
-  if (defined_default(parameters.bufferView)) {
-    return decodePrimitive(parameters);
-  }
-  return decodePointCloud(parameters);
-}
-async function initWorker(parameters, transferableObjects) {
-  const wasmConfig = parameters.webAssemblyConfig;
-  if (defined_default(wasmConfig) && defined_default(wasmConfig.wasmBinaryFile)) {
-    draco = await (0, import_draco_decoder_nodejs.default)(wasmConfig);
-  } else {
-    draco = await (0, import_draco_decoder_nodejs.default)();
-  }
-  return true;
-}
-async function decodeDraco(parameters, transferableObjects) {
-  const wasmConfig = parameters.webAssemblyConfig;
-  if (defined_default(wasmConfig)) {
-    return initWorker(parameters, transferableObjects);
-  }
-  return decode(parameters, transferableObjects);
-}
-var decodeDraco_default = createTaskProcessorWorker_default(decodeDraco);
-export {
-  decodeDraco_default as default
-};
+import{a as D}from"./chunk-35SHYARM.js";import{a as I}from"./chunk-WZDE3RYP.js";import{a as m}from"./chunk-OFUUQVMR.js";import{a as w}from"./chunk-AU7IKHOH.js";import"./chunk-3SSKC3VN.js";import"./chunk-OSW76XDF.js";import{a as A}from"./chunk-ED5JPB3S.js";import"./chunk-LEYMRMBK.js";import{d as P,e as d}from"./chunk-VTAIKJXX.js";var b=P(D(),1),r;function F(t,n){let o=t.num_points(),a=t.num_faces(),i=new r.DracoInt32Array,e=a*3,s=m.createTypedArray(o,e),u=0;for(let f=0;f<a;++f)n.GetFaceFromMesh(t,f,i),s[u+0]=i.GetValue(0),s[u+1]=i.GetValue(1),s[u+2]=i.GetValue(2),u+=3;return r.destroy(i),{typedArray:s,numberOfIndices:e}}function U(t,n,o,a,i){let e,s;a.quantizationBits<=8?(s=new r.DracoUInt8Array,e=new Uint8Array(i),n.GetAttributeUInt8ForAllPoints(t,o,s)):a.quantizationBits<=16?(s=new r.DracoUInt16Array,e=new Uint16Array(i),n.GetAttributeUInt16ForAllPoints(t,o,s)):(s=new r.DracoFloat32Array,e=new Float32Array(i),n.GetAttributeFloatForAllPoints(t,o,s));for(let u=0;u<i;++u)e[u]=s.GetValue(u);return r.destroy(s),e}function k(t,n,o,a){let i,e;switch(o.data_type()){case 1:case 11:e=new r.DracoInt8Array,i=new Int8Array(a),n.GetAttributeInt8ForAllPoints(t,o,e);break;case 2:e=new r.DracoUInt8Array,i=new Uint8Array(a),n.GetAttributeUInt8ForAllPoints(t,o,e);break;case 3:e=new r.DracoInt16Array,i=new Int16Array(a),n.GetAttributeInt16ForAllPoints(t,o,e);break;case 4:e=new r.DracoUInt16Array,i=new Uint16Array(a),n.GetAttributeUInt16ForAllPoints(t,o,e);break;case 5:case 7:e=new r.DracoInt32Array,i=new Int32Array(a),n.GetAttributeInt32ForAllPoints(t,o,e);break;case 6:case 8:e=new r.DracoUInt32Array,i=new Uint32Array(a),n.GetAttributeUInt32ForAllPoints(t,o,e);break;case 9:case 10:e=new r.DracoFloat32Array,i=new Float32Array(a),n.GetAttributeFloatForAllPoints(t,o,e);break}for(let s=0;s<a;++s)i[s]=e.GetValue(s);return r.destroy(e),i}function p(t,n,o){let a=t.num_points(),i=o.num_components(),e,s=new r.AttributeQuantizationTransform;if(s.InitFromAttribute(o)){let c=new Array(i);for(let y=0;y<i;++y)c[y]=s.min_value(y);e={quantizationBits:s.quantization_bits(),minValues:c,range:s.range(),octEncoded:!1}}r.destroy(s),s=new r.AttributeOctahedronTransform,s.InitFromAttribute(o)&&(e={quantizationBits:s.quantization_bits(),octEncoded:!0}),r.destroy(s);let u=a*i,f;d(e)?f=U(t,n,o,e,u):f=k(t,n,o,u);let l=w.fromTypedArray(f);return{array:f,data:{componentsPerAttribute:i,componentDatatype:l,byteOffset:o.byte_offset(),byteStride:w.getSizeInBytes(l)*i,normalized:o.normalized(),quantization:e}}}function O(t){let n=new r.Decoder;t.dequantizeInShader&&(n.SkipAttributeTransform(r.POSITION),n.SkipAttributeTransform(r.NORMAL));let o=new r.DecoderBuffer;if(o.Init(t.buffer,t.buffer.length),n.GetEncodedGeometryType(o)!==r.POINT_CLOUD)throw new A("Draco geometry type must be POINT_CLOUD.");let i=new r.PointCloud,e=n.DecodeBufferToPointCloud(o,i);if(!e.ok()||i.ptr===0)throw new A(`Error decoding draco point cloud: ${e.error_msg()}`);r.destroy(o);let s={},u=t.properties;for(let f in u)if(u.hasOwnProperty(f)){let l;if(f==="POSITION"||f==="NORMAL"){let c=n.GetAttributeId(i,r[f]);l=n.GetAttribute(i,c)}else{let c=u[f];l=n.GetAttributeByUniqueId(i,c)}s[f]=p(i,n,l)}return r.destroy(i),r.destroy(n),s}function g(t){let n=new r.Decoder;if(t.dequantizeInShader)for(let c=0;c<t.attributesToSkipTransform.length;++c)n.SkipAttributeTransform(r[t.attributesToSkipTransform[c]]);let o=t.bufferView,a=new r.DecoderBuffer;if(a.Init(t.array,o.byteLength),n.GetEncodedGeometryType(a)!==r.TRIANGULAR_MESH)throw new A("Unsupported draco mesh geometry type.");let e=new r.Mesh,s=n.DecodeBufferToMesh(a,e);if(!s.ok()||e.ptr===0)throw new A(`Error decoding draco mesh geometry: ${s.error_msg()}`);r.destroy(a);let u={},f=t.compressedAttributes;for(let c in f)if(f.hasOwnProperty(c)){let y=f[c],T=n.GetAttributeByUniqueId(e,y);u[c]=p(e,n,T)}let l={indexArray:F(e,n),attributeData:u};return r.destroy(e),r.destroy(n),l}async function z(t,n){return d(t.bufferView)?g(t):O(t)}async function G(t,n){let o=t.webAssemblyConfig;return d(o)&&d(o.wasmBinaryFile)?r=await(0,b.default)(o):r=await(0,b.default)(),!0}async function S(t,n){let o=t.webAssemblyConfig;return d(o)?G(t,n):z(t,n)}var h=I(S);export{h as default};