@loaders.gl/draco 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/dist.dev.js

@@ -2,8 +2,8 @@
   if (typeof exports === 'object' && typeof module === 'object')
     module.exports = factory();
   else if (typeof define === 'function' && define.amd) define([], factory);
-        else if (typeof exports === 'object') exports['loader'] = factory();
-  else root['loader'] = factory();})(globalThis, function () {
+        else if (typeof exports === 'object') exports['loaders'] = factory();
+  else root['loaders'] = factory();})(globalThis, function () {
 "use strict";
 var __exports__ = (() => {
   var __create = Object.create;
@@ -27,6 +27,7 @@ var __exports__ = (() => {
     }
     return to;
   };
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
   var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
     // If the importer is in node compatibility mode or this is not an ESM
     // file that has been converted to a CommonJS file using a Babel-
@@ -37,6 +38,13 @@ var __exports__ = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // external-global-plugin:@loaders.gl/core
+  var require_core = __commonJS({
+    "external-global-plugin:@loaders.gl/core"(exports, module) {
+      module.exports = globalThis.loaders;
+    }
+  });
+
   // (disabled):../worker-utils/src/lib/node/require-utils.node
   var require_require_utils = __commonJS({
     "(disabled):../worker-utils/src/lib/node/require-utils.node"() {
@@ -44,9 +52,9 @@ var __exports__ = (() => {
     }
   });
 
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
+  // bundle.ts
+  var bundle_exports = {};
+  __export(bundle_exports, {
     DRACO_EXTERNAL_LIBRARIES: () => DRACO_EXTERNAL_LIBRARIES,
     DRACO_EXTERNAL_LIBRARY_URLS: () => DRACO_EXTERNAL_LIBRARY_URLS,
     DracoLoader: () => DracoLoader2,
@@ -54,15 +62,17 @@ var __exports__ = (() => {
     DracoWriter: () => DracoWriter,
     DracoWriterWorker: () => DracoWriterWorker
   });
+  __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // src/lib/utils/version.ts
-  var VERSION = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // src/draco-loader.ts
   var DracoLoader = {
     name: "Draco",
     id: "draco",
     module: "draco",
+    // shapes: ['mesh'],
     version: VERSION,
     worker: true,
     extensions: ["drc"],
@@ -72,6 +82,7 @@ var __exports__ = (() => {
     options: {
       draco: {
         decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
+        // 'js' for IE11
         libraryPath: "libs/",
         extraAttributes: {},
         attributeNameEntry: void 0
@@ -125,7 +136,10 @@ var __exports__ = (() => {
       maxY = y > maxY ? y : maxY;
       maxZ = z > maxZ ? z : maxZ;
     }
-    return [[minX, minY, minZ], [maxX, maxY, maxZ]];
+    return [
+      [minX, minY, minZ],
+      [maxX, maxY, maxZ]
+    ];
   }
 
   // ../schema/src/lib/mesh/deduce-mesh-schema.ts
@@ -134,14 +148,7 @@ var __exports__ = (() => {
     const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
     return {
       name,
-      type: {
-        type: "fixed-size-list",
-        listSize: attribute.size,
-        children: [{
-          name: "value",
-          type
-        }]
-      },
+      type: { type: "fixed-size-list", listSize: attribute.size, children: [{ name: "value", type }] },
       nullable: false,
       metadata
     };
@@ -167,17 +174,18 @@ var __exports__ = (() => {
     const namedLoaderDataAttributes = transformAttributesLoaderData(loaderData.attributes);
     for (const attributeName in attributes) {
       const attribute = attributes[attributeName];
-      const field = getArrowFieldFromAttribute(attributeName, attribute, namedLoaderDataAttributes[attributeName]);
+      const field = getArrowFieldFromAttribute(
+        attributeName,
+        attribute,
+        namedLoaderDataAttributes[attributeName]
+      );
       fields.push(field);
     }
     if (indices) {
       const indicesField = getArrowFieldFromAttribute("indices", indices);
       fields.push(indicesField);
     }
-    return {
-      fields,
-      metadata
-    };
+    return { fields, metadata };
   }
   function transformAttributesLoaderData(loaderData) {
     const result = {};
@@ -219,15 +227,27 @@ var __exports__ = (() => {
   };
   var INDEX_ITEM_SIZE = 4;
   var DracoParser = class {
+    draco;
+    decoder;
+    metadataQuerier;
+    // draco - the draco decoder, either import `draco3d` or load dynamically
     constructor(draco) {
       this.draco = draco;
       this.decoder = new this.draco.Decoder();
       this.metadataQuerier = new this.draco.MetadataQuerier();
     }
+    /**
+     * Destroy draco resources
+     */
     destroy() {
       this.draco.destroy(this.decoder);
       this.draco.destroy(this.metadataQuerier);
     }
+    /**
+     * NOTE: caller must call `destroyGeometry` on the return value after using it
+     * @param arrayBuffer
+     * @param options
+     */
     parseSync(arrayBuffer, options = {}) {
       const buffer = new this.draco.DecoderBuffer();
       buffer.Init(new Int8Array(arrayBuffer), arrayBuffer.byteLength);
@@ -272,6 +292,14 @@ var __exports__ = (() => {
         }
       }
     }
+    // Draco specific "loader data"
+    /**
+     * Extract
+     * @param dracoGeometry
+     * @param geometry_type
+     * @param options
+     * @returns
+     */
     _getDracoLoaderData(dracoGeometry, geometry_type, options) {
       const metadata = this._getTopLevelMetadata(dracoGeometry);
       const attributes = this._getDracoAttributes(dracoGeometry, options);
@@ -284,6 +312,12 @@ var __exports__ = (() => {
         attributes
       };
     }
+    /**
+     * Extract all draco provided information and metadata for each attribute
+     * @param dracoGeometry
+     * @param options
+     * @returns
+     */
     _getDracoAttributes(dracoGeometry, options) {
       const dracoAttributes = {};
       for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {
@@ -311,6 +345,12 @@ var __exports__ = (() => {
       }
       return dracoAttributes;
     }
+    /**
+     * Get standard loaders.gl mesh category data
+     * Extracts the geometry from draco
+     * @param dracoGeometry
+     * @param options
+     */
     _getMeshData(dracoGeometry, loaderData, options) {
       const attributes = this._getMeshAttributes(loaderData, dracoGeometry, options);
       const positionAttribute = attributes.POSITION;
@@ -323,6 +363,7 @@ var __exports__ = (() => {
             return {
               topology: "triangle-strip",
               mode: 4,
+              // GL.TRIANGLES
               attributes,
               indices: {
                 value: this._getTriangleStripIndices(dracoGeometry),
@@ -334,6 +375,7 @@ var __exports__ = (() => {
             return {
               topology: "triangle-list",
               mode: 5,
+              // GL.TRIANGLE_STRIP
               attributes,
               indices: {
                 value: this._getTriangleListIndices(dracoGeometry),
@@ -345,6 +387,7 @@ var __exports__ = (() => {
       return {
         topology: "point-list",
         mode: 0,
+        // GL.POINTS
         attributes
       };
     }
@@ -353,10 +396,7 @@ var __exports__ = (() => {
       for (const loaderAttribute of Object.values(loaderData.attributes)) {
         const attributeName = this._deduceAttributeName(loaderAttribute, options);
         loaderAttribute.name = attributeName;
-        const {
-          value,
-          size
-        } = this._getAttributeValues(dracoGeometry, loaderAttribute);
+        const { value, size } = this._getAttributeValues(dracoGeometry, loaderAttribute);
         attributes[attributeName] = {
           value,
           size,
@@ -367,6 +407,11 @@ var __exports__ = (() => {
       }
       return attributes;
     }
+    // MESH INDICES EXTRACTION
+    /**
+     * For meshes, we need indices to define the faces.
+     * @param dracoGeometry
+     */
     _getTriangleListIndices(dracoGeometry) {
       const numFaces = dracoGeometry.num_faces();
       const numIndices = numFaces * 3;
@@ -379,6 +424,10 @@ var __exports__ = (() => {
         this.draco._free(ptr);
       }
     }
+    /**
+     * For meshes, we need indices to define the faces.
+     * @param dracoGeometry
+     */
     _getTriangleStripIndices(dracoGeometry) {
       const dracoArray = new this.draco.DracoInt32Array();
       try {
@@ -388,6 +437,12 @@ var __exports__ = (() => {
         this.draco.destroy(dracoArray);
       }
     }
+    /**
+     *
+     * @param dracoGeometry
+     * @param dracoAttribute
+     * @param attributeName
+     */
     _getAttributeValues(dracoGeometry, attribute) {
       const TypedArrayCtor = DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP[attribute.data_type];
       const numComponents = attribute.num_components;
@@ -399,19 +454,48 @@ var __exports__ = (() => {
       const ptr = this.draco._malloc(byteLength);
       try {
         const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attribute.attribute_index);
-        this.decoder.GetAttributeDataArrayForAllPoints(dracoGeometry, dracoAttribute, dataType, byteLength, ptr);
+        this.decoder.GetAttributeDataArrayForAllPoints(
+          dracoGeometry,
+          dracoAttribute,
+          dataType,
+          byteLength,
+          ptr
+        );
         value = new TypedArrayCtor(this.draco.HEAPF32.buffer, ptr, numValues).slice();
       } finally {
         this.draco._free(ptr);
       }
-      return {
-        value,
-        size: numComponents
-      };
-    }
+      return { value, size: numComponents };
+    }
+    // Attribute names
+    /** 
+     * DRACO does not store attribute names - We need to deduce an attribute name
+     * for each attribute
+    _getAttributeNames(
+      dracoGeometry: Mesh | PointCloud,
+      options: DracoParseOptions
+    ): {[unique_id: number]: string} {
+      const attributeNames: {[unique_id: number]: string} = {};
+      for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {
+        const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);
+        const attributeName = this._deduceAttributeName(dracoAttribute, options);
+        attributeNames[attributeName] = attributeName;
+      }
+      return attributeNames;
+    }
+     */
+    /**
+     * Deduce an attribute name.
+     * @note DRACO does not save attribute names, just general type (POSITION, COLOR)
+     * to help optimize compression. We generate GLTF compatible names for the Draco-recognized
+     * types
+     * @param attributeData
+     */
     _deduceAttributeName(attribute, options) {
       const uniqueId = attribute.unique_id;
-      for (const [attributeName, attributeUniqueId] of Object.entries(options.extraAttributes || {})) {
+      for (const [attributeName, attributeUniqueId] of Object.entries(
+        options.extraAttributes || {}
+      )) {
         if (attributeUniqueId === uniqueId) {
           return attributeName;
         }
@@ -429,14 +513,22 @@ var __exports__ = (() => {
       }
       return `CUSTOM_ATTRIBUTE_${uniqueId}`;
     }
+    // METADATA EXTRACTION
+    /** Get top level metadata */
     _getTopLevelMetadata(dracoGeometry) {
       const dracoMetadata = this.decoder.GetMetadata(dracoGeometry);
       return this._getDracoMetadata(dracoMetadata);
     }
+    /** Get per attribute metadata */
     _getAttributeMetadata(dracoGeometry, attributeId) {
       const dracoMetadata = this.decoder.GetAttributeMetadata(dracoGeometry, attributeId);
       return this._getDracoMetadata(dracoMetadata);
     }
+    /**
+     * Extract metadata field values
+     * @param dracoMetadata
+     * @returns
+     */
     _getDracoMetadata(dracoMetadata) {
       if (!dracoMetadata || !dracoMetadata.ptr) {
         return {};
@@ -449,6 +541,11 @@ var __exports__ = (() => {
       }
       return result;
     }
+    /**
+     * Extracts possible values for one metadata entry by name
+     * @param dracoMetadata
+     * @param entryName
+     */
     _getDracoMetadataField(dracoMetadata, entryName) {
       const dracoArray = new this.draco.DracoInt32Array();
       try {
@@ -464,20 +561,21 @@ var __exports__ = (() => {
         this.draco.destroy(dracoArray);
       }
     }
+    // QUANTIZED ATTRIBUTE SUPPORT (NO DECOMPRESSION)
+    /** Skip transforms for specific attribute types */
     _disableAttributeTransforms(options) {
-      const {
-        quantizedAttributes = [],
-        octahedronAttributes = []
-      } = options;
+      const { quantizedAttributes = [], octahedronAttributes = [] } = options;
       const skipAttributes = [...quantizedAttributes, ...octahedronAttributes];
       for (const dracoAttributeName of skipAttributes) {
         this.decoder.SkipAttributeTransform(this.draco[dracoAttributeName]);
       }
     }
+    /**
+     * Extract (and apply?) Position Transform
+     * @todo not used
+     */
     _getQuantizationTransform(dracoAttribute, options) {
-      const {
-        quantizedAttributes = []
-      } = options;
+      const { quantizedAttributes = [] } = options;
       const attribute_type = dracoAttribute.attribute_type();
       const skip = quantizedAttributes.map((type) => this.decoder[type]).includes(attribute_type);
       if (skip) {
@@ -497,9 +595,7 @@ var __exports__ = (() => {
       return null;
     }
     _getOctahedronTransform(dracoAttribute, options) {
-      const {
-        octahedronAttributes = []
-      } = options;
+      const { octahedronAttributes = [] } = options;
       const attribute_type = dracoAttribute.attribute_type();
       const octahedron = octahedronAttributes.map((type) => this.decoder[type]).includes(attribute_type);
       if (octahedron) {
@@ -516,6 +612,7 @@ var __exports__ = (() => {
       }
       return null;
     }
+    // HELPERS
   };
   function getDracoDataType(draco, attributeType) {
     switch (attributeType) {
@@ -555,14 +652,17 @@ var __exports__ = (() => {
   }
 
   // ../worker-utils/src/lib/env-utils/version.ts
+  var NPM_TAG = "latest";
   function getVersion() {
     if (!globalThis._loadersgl_?.version) {
       globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-      if (false) {
-        console.warn("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+      if (typeof __VERSION__ === "undefined") {
+        console.warn(
+          "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
+        );
         globalThis._loadersgl_.version = NPM_TAG;
       } else {
-        globalThis._loadersgl_.version = "4.2.0-alpha.4";
+        globalThis._loadersgl_.version = __VERSION__;
       }
     }
     return globalThis._loadersgl_.version;
@@ -587,7 +687,10 @@ var __exports__ = (() => {
   var window_ = globals.window || globals.self || globals.global || {};
   var global_ = globals.global || globals.self || globals.window || {};
   var document_ = globals.document || {};
-  var isBrowser = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
+  var isBrowser = (
+    // @ts-ignore process.browser
+    typeof process !== "object" || String(process) !== "[object process]" || process.browser
+  );
   var isWorker = typeof importScripts === "function";
   var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
@@ -600,7 +703,8 @@ var __exports__ = (() => {
     if (moduleName) {
       libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
     }
-    loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
+    loadLibraryPromises[libraryUrl] = // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
     return await loadLibraryPromises[libraryUrl];
   }
   function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
@@ -680,9 +784,13 @@ var __exports__ = (() => {
   var DRACO_ENCODER_VERSION = "1.4.1";
   var STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
   var DRACO_EXTERNAL_LIBRARIES = {
+    /** The primary Draco3D encoder, javascript wrapper part */
     DECODER: "draco_wasm_wrapper.js",
+    /** The primary draco decoder, compiled web assembly part */
     DECODER_WASM: "draco_decoder.wasm",
+    /** Fallback decoder for non-webassebly environments. Very big bundle, lower performance */
     FALLBACK_DECODER: "draco_decoder.js",
+    /** Draco encoder */
     ENCODER: "draco_encoder.js"
   };
   var DRACO_EXTERNAL_LIBRARY_URLS = {
@@ -697,9 +805,7 @@ var __exports__ = (() => {
     const modules = options.modules || {};
     if (modules.draco3d) {
       loadDecoderPromise = loadDecoderPromise || modules.draco3d.createDecoderModule({}).then((draco) => {
-        return {
-          draco
-        };
+        return { draco };
       });
     } else {
       loadDecoderPromise = loadDecoderPromise || loadDracoDecoder(options);
@@ -710,9 +816,7 @@ var __exports__ = (() => {
     const modules = options.modules || {};
     if (modules.draco3d) {
       loadEncoderPromise = loadEncoderPromise || modules.draco3d.createEncoderModule({}).then((draco) => {
-        return {
-          draco
-        };
+        return { draco };
       });
     } else {
       loadEncoderPromise = loadEncoderPromise || loadDracoEncoder(options);
@@ -724,11 +828,29 @@ var __exports__ = (() => {
     let wasmBinary;
     switch (options.draco && options.draco.decoderType) {
       case "js":
-        DracoDecoderModule = await loadLibrary(DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER], "draco", options, DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER);
+        DracoDecoderModule = await loadLibrary(
+          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER],
+          "draco",
+          options,
+          DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER
+        );
         break;
       case "wasm":
       default:
-        [DracoDecoderModule, wasmBinary] = await Promise.all([await loadLibrary(DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER], "draco", options, DRACO_EXTERNAL_LIBRARIES.DECODER), await loadLibrary(DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM], "draco", options, DRACO_EXTERNAL_LIBRARIES.DECODER_WASM)]);
+        [DracoDecoderModule, wasmBinary] = await Promise.all([
+          await loadLibrary(
+            DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
+            "draco",
+            options,
+            DRACO_EXTERNAL_LIBRARIES.DECODER
+          ),
+          await loadLibrary(
+            DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
+            "draco",
+            options,
+            DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
+          )
+        ]);
     }
     DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
     return await initializeDracoDecoder(DracoDecoderModule, wasmBinary);
@@ -741,20 +863,23 @@ var __exports__ = (() => {
     return new Promise((resolve) => {
       DracoDecoderModule({
         ...options,
-        onModuleLoaded: (draco) => resolve({
-          draco
-        })
+        onModuleLoaded: (draco) => resolve({ draco })
+        // Module is Promise-like. Wrap in object to avoid loop.
       });
     });
   }
   async function loadDracoEncoder(options) {
-    let DracoEncoderModule = await loadLibrary(DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.ENCODER], "draco", options, DRACO_EXTERNAL_LIBRARIES.ENCODER);
+    let DracoEncoderModule = await loadLibrary(
+      DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.ENCODER],
+      "draco",
+      options,
+      DRACO_EXTERNAL_LIBRARIES.ENCODER
+    );
     DracoEncoderModule = DracoEncoderModule || globalThis.DracoEncoderModule;
     return new Promise((resolve) => {
       DracoEncoderModule({
-        onModuleLoaded: (draco) => resolve({
-          draco
-        })
+        onModuleLoaded: (draco) => resolve({ draco })
+        // Module is Promise-like. Wrap in object to avoid loop.
       });
     });
   }
@@ -769,6 +894,12 @@ var __exports__ = (() => {
   var noop = () => {
   };
   var DracoBuilder = class {
+    draco;
+    dracoEncoder;
+    dracoMeshBuilder;
+    dracoMetadataBuilder;
+    log;
+    // draco - the draco decoder, either import `draco3d` or load dynamically
     constructor(draco) {
       this.draco = draco;
       this.dracoEncoder = new this.draco.Encoder();
@@ -783,21 +914,25 @@ var __exports__ = (() => {
       this.dracoEncoder = null;
       this.draco = null;
     }
+    // TBD - when does this need to be called?
     destroyEncodedObject(object) {
       if (object) {
         this.draco.destroy(object);
       }
     }
+    /**
+     * Encode mesh or point cloud
+     * @param mesh =({})
+     * @param options
+     */
     encodeSync(mesh, options = {}) {
       this.log = noop;
       this._setOptions(options);
       return options.pointcloud ? this._encodePointCloud(mesh, options) : this._encodeMesh(mesh, options);
     }
+    // PRIVATE
     _getAttributesFromMesh(mesh) {
-      const attributes = {
-        ...mesh,
-        ...mesh.attributes
-      };
+      const attributes = { ...mesh, ...mesh.attributes };
       if (mesh.indices) {
         attributes.indices = mesh.indices;
       }
@@ -812,7 +947,11 @@ var __exports__ = (() => {
       this._createDracoPointCloud(dracoPointCloud, attributes, options);
       const dracoData = new this.draco.DracoInt8Array();
       try {
-        const encodedLen = this.dracoEncoder.EncodePointCloudToDracoBuffer(dracoPointCloud, false, dracoData);
+        const encodedLen = this.dracoEncoder.EncodePointCloudToDracoBuffer(
+          dracoPointCloud,
+          false,
+          dracoData
+        );
         if (!(encodedLen > 0)) {
           throw new Error("Draco encoding failed.");
         }
@@ -845,6 +984,10 @@ var __exports__ = (() => {
         this.destroyEncodedObject(dracoMesh);
       }
     }
+    /**
+     * Set encoding options.
+     * @param {{speed?: any; method?: any; quantization?: any;}} options
+     */
     _setOptions(options) {
       if ("speed" in options) {
         this.dracoEncoder.SetSpeedOptions(...options.speed);
@@ -861,6 +1004,11 @@ var __exports__ = (() => {
         }
       }
     }
+    /**
+     * @param {Mesh} dracoMesh
+     * @param {object} attributes
+     * @returns {Mesh}
+     */
     _createDracoMesh(dracoMesh, attributes, options) {
       const optionalMetadata = options.attributesMetadata || {};
       try {
@@ -886,6 +1034,10 @@ var __exports__ = (() => {
       }
       return dracoMesh;
     }
+    /**
+     * @param {} dracoPointCloud
+     * @param {object} attributes
+     */
     _createDracoPointCloud(dracoPointCloud, attributes, options) {
       const optionalMetadata = options.attributesMetadata || {};
       try {
@@ -897,7 +1049,12 @@ var __exports__ = (() => {
         for (let attributeName in attributes) {
           const attribute = attributes[attributeName];
           attributeName = GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP[attributeName] || attributeName;
-          const uniqueId = this._addAttributeToMesh(dracoPointCloud, attributeName, attribute, vertexCount);
+          const uniqueId = this._addAttributeToMesh(
+            dracoPointCloud,
+            attributeName,
+            attribute,
+            vertexCount
+          );
           if (uniqueId !== -1) {
             this._addAttributeMetadata(dracoPointCloud, uniqueId, {
               name: attributeName,
@@ -911,6 +1068,12 @@ var __exports__ = (() => {
       }
       return dracoPointCloud;
     }
+    /**
+     * @param mesh
+     * @param attributeName
+     * @param attribute
+     * @param vertexCount
+     */
     _addAttributeToMesh(mesh, attributeName, attribute, vertexCount) {
       if (!ArrayBuffer.isView(attribute)) {
         return -1;
@@ -925,9 +1088,7 @@ var __exports__ = (() => {
       }
       this.log(`Adding attribute ${attributeName}, size ${size}`);
       const builder = this.dracoMeshBuilder;
-      const {
-        buffer
-      } = attribute;
+      const { buffer } = attribute;
       switch (attribute.constructor) {
         case Int8Array:
           return builder.AddInt8Attribute(mesh, type, vertexCount, size, new Int8Array(buffer));
@@ -947,6 +1108,11 @@ var __exports__ = (() => {
           return builder.AddFloatAttribute(mesh, type, vertexCount, size, new Float32Array(buffer));
       }
     }
+    /**
+     * DRACO can compress attributes of know type better
+     * TODO - expose an attribute type map?
+     * @param attributeName
+     */
     _getDracoAttributeType(attributeName) {
       switch (attributeName.toLowerCase()) {
         case "indices":
@@ -978,16 +1144,36 @@ var __exports__ = (() => {
       }
       return null;
     }
+    /**
+     * Add metadata for the geometry.
+     * @param dracoGeometry - WASM Draco Object
+     * @param metadata
+     */
     _addGeometryMetadata(dracoGeometry, metadata) {
       const dracoMetadata = new this.draco.Metadata();
       this._populateDracoMetadata(dracoMetadata, metadata);
       this.dracoMeshBuilder.AddMetadata(dracoGeometry, dracoMetadata);
     }
+    /**
+     * Add metadata for an attribute to geometry.
+     * @param dracoGeometry - WASM Draco Object
+     * @param uniqueAttributeId
+     * @param metadata
+     */
     _addAttributeMetadata(dracoGeometry, uniqueAttributeId, metadata) {
       const dracoAttributeMetadata = new this.draco.Metadata();
       this._populateDracoMetadata(dracoAttributeMetadata, metadata);
-      this.dracoMeshBuilder.SetMetadataForAttribute(dracoGeometry, uniqueAttributeId, dracoAttributeMetadata);
-    }
+      this.dracoMeshBuilder.SetMetadataForAttribute(
+        dracoGeometry,
+        uniqueAttributeId,
+        dracoAttributeMetadata
+      );
+    }
+    /**
+     * Add contents of object or map to a WASM Draco Metadata Object
+     * @param dracoMetadata - WASM Draco Object
+     * @param metadata
+     */
     _populateDracoMetadata(dracoMetadata, metadata) {
       for (const [key, value] of getEntries(metadata)) {
         switch (typeof value) {
@@ -1027,7 +1213,14 @@ var __exports__ = (() => {
   // src/draco-writer.ts
   var DEFAULT_DRACO_WRITER_OPTIONS = {
     pointcloud: false,
+    // Set to true if pointcloud (mode: 0, no indices)
     attributeNameEntry: "name"
+    // Draco Compression Parameters
+    // method: 'MESH_EDGEBREAKER_ENCODING', // Use draco defaults
+    // speed: [5, 5], // Use draco defaults
+    // quantization: { // Use draco defaults
+    //   POSITION: 10
+    // }
   };
   var DracoWriter = {
     name: "DRACO",
@@ -1041,9 +1234,7 @@ var __exports__ = (() => {
     encode
   };
   async function encode(data, options = {}) {
-    const {
-      draco
-    } = await loadDracoEncoderModule(options);
+    const { draco } = await loadDracoEncoderModule(options);
     const dracoBuilder = new DracoBuilder(draco);
     try {
       return dracoBuilder.encodeSync(data, options.draco);
@@ -1069,9 +1260,7 @@ var __exports__ = (() => {
     parse
   };
   async function parse(arrayBuffer, options) {
-    const {
-      draco
-    } = await loadDracoDecoderModule(options);
+    const { draco } = await loadDracoDecoderModule(options);
     const dracoParser = new DracoParser(draco);
     try {
       return dracoParser.parseSync(arrayBuffer, options?.draco);
@@ -1079,7 +1268,7 @@ var __exports__ = (() => {
       dracoParser.destroy();
     }
   }
-  return __toCommonJS(src_exports);
+  return __toCommonJS(bundle_exports);
 })();
       return __exports__;
       });