@rtzh/engine 0.0.1 → 0.0.3

package/Build/Workers/createWallOutlineGeometry.js

@@ -1,335 +0,0 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 0.0.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.
- */
-
-import {
-  WallGeometryLibrary_default
-} from "./chunk-PLLZB3R4.js";
-import "./chunk-Q2DXNFYW.js";
-import "./chunk-AIW5F22O.js";
-import "./chunk-HAY6YE7M.js";
-import "./chunk-FVYRV2T6.js";
-import "./chunk-66YGZWBI.js";
-import "./chunk-J4MIJCN5.js";
-import {
-  IndexDatatype_default
-} from "./chunk-55IROWAX.js";
-import {
-  GeometryAttributes_default
-} from "./chunk-BOV6T7FO.js";
-import {
-  GeometryAttribute_default,
-  Geometry_default,
-  PrimitiveType_default
-} from "./chunk-XOVHLPKW.js";
-import {
-  BoundingSphere_default
-} from "./chunk-OAOREOSO.js";
-import "./chunk-EKMWNF4U.js";
-import "./chunk-KQIZ7AFF.js";
-import "./chunk-POY6ZE32.js";
-import {
-  ComponentDatatype_default
-} from "./chunk-AL22JVIA.js";
-import "./chunk-5VZISKJF.js";
-import "./chunk-UYT2PBMV.js";
-import {
-  Ellipsoid_default
-} from "./chunk-YPGJSFOO.js";
-import {
-  Cartesian3_default,
-  Frozen_default
-} from "./chunk-QWV2DM66.js";
-import {
-  Math_default
-} from "./chunk-6XJO625E.js";
-import {
-  DeveloperError_default
-} from "./chunk-KH2OWUUA.js";
-import {
-  defined_default
-} from "./chunk-AVSQILVI.js";
-
-// packages/engine/Source/Core/WallOutlineGeometry.js
-var scratchCartesian3Position1 = new Cartesian3_default();
-var scratchCartesian3Position2 = new Cartesian3_default();
-function WallOutlineGeometry(options) {
-  options = options ?? Frozen_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 = options.granularity ?? Math_default.RADIANS_PER_DEGREE;
-  const ellipsoid = options.ellipsoid ?? Ellipsoid_default.default;
-  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 = 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 = 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 = options ?? Frozen_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
-};

package/Build/Workers/decodeDraco.js

@@ -1,369 +0,0 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 0.0.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.
- */
-
-import {
-  require_draco_decoder_nodejs
-} from "./chunk-56XTN5NJ.js";
-import {
-  createTaskProcessorWorker_default
-} from "./chunk-TSAJNE4K.js";
-import {
-  IndexDatatype_default
-} from "./chunk-55IROWAX.js";
-import {
-  ComponentDatatype_default
-} from "./chunk-AL22JVIA.js";
-import "./chunk-5VZISKJF.js";
-import {
-  RuntimeError_default
-} from "./chunk-UYT2PBMV.js";
-import "./chunk-6XJO625E.js";
-import "./chunk-KH2OWUUA.js";
-import {
-  __toESM,
-  defined_default
-} from "./chunk-AVSQILVI.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();
-  if (parameters.dequantizeInShader) {
-    for (let i = 0; i < parameters.attributesToSkipTransform.length; ++i) {
-      dracoDecoder.SkipAttributeTransform(
-        draco[parameters.attributesToSkipTransform[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
-};