@loaders.gl/gltf 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, {
     EXT_FEATURE_METADATA: () => name3,
     EXT_MESH_FEATURES: () => name,
     EXT_STRUCTURAL_METADATA: () => name2,
@@ -58,6 +66,7 @@ var __exports__ = (() => {
     _getMemoryUsageGLTF: () => getMemoryUsageGLTF,
     postProcessGLTF: () => postProcessGLTF
   });
+  __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // src/lib/extensions/EXT_mesh_features.ts
   var EXT_mesh_features_exports = {};
@@ -67,7 +76,7 @@ var __exports__ = (() => {
   });
 
   // ../images/src/lib/utils/version.ts
-  var VERSION = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // ../loader-utils/src/loader-types.ts
   async function parseFromContext(data, loaders, options, context) {
@@ -92,19 +101,25 @@ var __exports__ = (() => {
   var window_ = globals.window || globals.self || globals.global || {};
   var global_ = globals.global || globals.self || globals.window || {};
   var document_ = globals.document || {};
-  var isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
+  var isBrowser = (
+    // @ts-ignore process does not exist on browser
+    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
+  );
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
   // ../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;
@@ -129,7 +144,10 @@ var __exports__ = (() => {
   var window_2 = globals2.window || globals2.self || globals2.global || {};
   var global_2 = globals2.global || globals2.self || globals2.window || {};
   var document_2 = globals2.document || {};
-  var isBrowser2 = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
+  var isBrowser2 = (
+    // @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 matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
@@ -142,7 +160,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) {
@@ -281,7 +300,11 @@ var __exports__ = (() => {
     const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);
     const padLength = paddedLength - sourceBuffer.byteLength;
     if (dataView) {
-      const targetArray = new Uint8Array(dataView.buffer, dataView.byteOffset + byteOffset, sourceBuffer.byteLength);
+      const targetArray = new Uint8Array(
+        dataView.buffer,
+        dataView.byteOffset + byteOffset,
+        sourceBuffer.byteLength
+      );
       const sourceArray = new Uint8Array(sourceBuffer);
       targetArray.set(sourceArray);
       for (let i2 = 0; i2 < padLength; ++i2) {
@@ -483,10 +506,7 @@ var __exports__ = (() => {
     switch (brandMajor) {
       case "avif":
       case "avis":
-        return {
-          extension: "avif",
-          mimeType: "image/avif"
-        };
+        return { extension: "avif", mimeType: "image/avif" };
       default:
         return null;
     }
@@ -522,6 +542,7 @@ var __exports__ = (() => {
     }
     return {
       mimeType: mediaType.mimeType,
+      // TODO - decode width and height
       width: 0,
       height: 0
     };
@@ -568,10 +589,7 @@ var __exports__ = (() => {
     if (!isJpeg) {
       return null;
     }
-    const {
-      tableMarkers,
-      sofMarkers
-    } = getJpegMarkers();
+    const { tableMarkers, sofMarkers } = getJpegMarkers();
     let i2 = 2;
     while (i2 + 9 < dataView.byteLength) {
       const marker = dataView.getUint16(i2, BIG_ENDIAN);
@@ -579,7 +597,9 @@ var __exports__ = (() => {
         return {
           mimeType: "image/jpeg",
           height: dataView.getUint16(i2 + 5, BIG_ENDIAN),
+          // Number of lines
           width: dataView.getUint16(i2 + 7, BIG_ENDIAN)
+          // Number of pixels per line
         };
       }
       if (!tableMarkers.has(marker)) {
@@ -595,11 +615,23 @@ var __exports__ = (() => {
     for (let i2 = 65504; i2 < 65520; ++i2) {
       tableMarkers.add(i2);
     }
-    const sofMarkers = /* @__PURE__ */ new Set([65472, 65473, 65474, 65475, 65477, 65478, 65479, 65481, 65482, 65483, 65485, 65486, 65487, 65502]);
-    return {
-      tableMarkers,
-      sofMarkers
-    };
+    const sofMarkers = /* @__PURE__ */ new Set([
+      65472,
+      65473,
+      65474,
+      65475,
+      65477,
+      65478,
+      65479,
+      65481,
+      65482,
+      65483,
+      65485,
+      65486,
+      65487,
+      65502
+    ]);
+    return { tableMarkers, sofMarkers };
   }
   function toDataView(data) {
     if (data instanceof DataView) {
@@ -616,9 +648,7 @@ var __exports__ = (() => {
 
   // ../images/src/lib/parsers/parse-to-node-image.ts
   async function parseToNodeImage(arrayBuffer, options) {
-    const {
-      mimeType
-    } = getBinaryImageMetadata(arrayBuffer) || {};
+    const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
     const parseImageNode2 = globalThis.loaders?.parseImageNode;
     assert(parseImageNode2);
     return await parseImageNode2(arrayBuffer, mimeType);
@@ -629,9 +659,7 @@ var __exports__ = (() => {
     options = options || {};
     const imageOptions = options.image || {};
     const imageType = imageOptions.type || "auto";
-    const {
-      url
-    } = context || {};
+    const { url } = context || {};
     const loadType = getLoadableImageType(imageType);
     let image;
     switch (loadType) {
@@ -665,12 +693,23 @@ var __exports__ = (() => {
 
   // ../images/src/image-loader.ts
   var EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
-  var MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp", "image/avif", "image/bmp", "image/vnd.microsoft.icon", "image/svg+xml"];
+  var MIME_TYPES = [
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+    "image/avif",
+    "image/bmp",
+    "image/vnd.microsoft.icon",
+    "image/svg+xml"
+  ];
   var DEFAULT_IMAGE_LOADER_OPTIONS = {
     image: {
       type: "auto",
       decode: true
+      // if format is HTML
     }
+    // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor
   };
   var ImageLoader = {
     id: "image",
@@ -680,6 +719,7 @@ var __exports__ = (() => {
     mimeTypes: MIME_TYPES,
     extensions: EXTENSIONS,
     parse: parseImage,
+    // TODO: byteOffset, byteLength;
     tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
     options: DEFAULT_IMAGE_LOADER_OPTIONS
   };
@@ -737,18 +777,34 @@ var __exports__ = (() => {
   };
   var BYTES = {
     5120: 1,
+    // BYTE
     5121: 1,
+    // UNSIGNED_BYTE
     5122: 2,
+    // SHORT
     5123: 2,
+    // UNSIGNED_SHORT
     5125: 4,
+    // UNSIGNED_INT
     5126: 4
+    // FLOAT
   };
 
   // src/lib/gltf-utils/gltf-utils.ts
   var MIPMAP_FACTOR = 1.33;
   var TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
-  var ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [[Int8Array, 5120], [Uint8Array, 5121], [Int16Array, 5122], [Uint16Array, 5123], [Uint32Array, 5125], [Float32Array, 5126], [Float64Array, 5130]];
-  var ARRAY_TO_COMPONENT_TYPE = new Map(ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT);
+  var ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
+    [Int8Array, 5120],
+    [Uint8Array, 5121],
+    [Int16Array, 5122],
+    [Uint16Array, 5123],
+    [Uint32Array, 5125],
+    [Float32Array, 5126],
+    [Float64Array, 5130]
+  ];
+  var ARRAY_TO_COMPONENT_TYPE = new Map(
+    ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT
+  );
   var ATTRIBUTE_TYPE_TO_COMPONENTS = {
     SCALAR: 1,
     VEC2: 2,
@@ -794,29 +850,17 @@ var __exports__ = (() => {
     assert3(byteLength >= 0 && byteLength <= bufferView.byteLength);
     const componentByteSize = BYTES[accessor.componentType];
     const numberOfComponentsInElement = COMPONENTS[accessor.type];
-    return {
-      ArrayType,
-      length,
-      byteLength,
-      componentByteSize,
-      numberOfComponentsInElement
-    };
+    return { ArrayType, length, byteLength, componentByteSize, numberOfComponentsInElement };
   }
   function getMemoryUsageGLTF(gltf) {
-    let {
-      images,
-      bufferViews
-    } = gltf;
+    let { images, bufferViews } = gltf;
     images = images || [];
     bufferViews = bufferViews || [];
     const imageBufferViews = images.map((i2) => i2.bufferView);
     bufferViews = bufferViews.filter((view) => !imageBufferViews.includes(view));
     const bufferMemory = bufferViews.reduce((acc, view) => acc + view.byteLength, 0);
     const pixelCount = images.reduce((acc, image) => {
-      const {
-        width,
-        height
-      } = image.image;
+      const { width, height } = image.image;
       return acc + width * height;
     }, 0);
     return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);
@@ -841,17 +885,9 @@ var __exports__ = (() => {
     if (!bufferView) {
       throw new Error(`No gltf buffer view for accessor ${bufferView}`);
     }
-    const {
-      arrayBuffer,
-      byteOffset: bufferByteOffset
-    } = buffers[bufferView.buffer];
+    const { arrayBuffer, byteOffset: bufferByteOffset } = buffers[bufferView.buffer];
     const byteOffset = (bufferByteOffset || 0) + (gltfAccessor.byteOffset || 0) + (bufferView.byteOffset || 0);
-    const {
-      ArrayType,
-      length,
-      componentByteSize,
-      numberOfComponentsInElement
-    } = getAccessorArrayTypeAndLength(gltfAccessor, bufferView);
+    const { ArrayType, length, componentByteSize, numberOfComponentsInElement } = getAccessorArrayTypeAndLength(gltfAccessor, bufferView);
     const elementByteSize = componentByteSize * numberOfComponentsInElement;
     const elementAddressScale = bufferView.byteStride || elementByteSize;
     if (typeof bufferView.byteStride === "undefined" || bufferView.byteStride === elementByteSize) {
@@ -860,7 +896,11 @@ var __exports__ = (() => {
     }
     const result = new ArrayType(length);
     for (let i2 = 0; i2 < gltfAccessor.count; i2++) {
-      const values = new ArrayType(arrayBuffer, byteOffset + i2 * elementAddressScale, numberOfComponentsInElement);
+      const values = new ArrayType(
+        arrayBuffer,
+        byteOffset + i2 * elementAddressScale,
+        numberOfComponentsInElement
+      );
       result.set(values, i2 * numberOfComponentsInElement);
     }
     return result;
@@ -880,6 +920,11 @@ var __exports__ = (() => {
     };
   }
   var GLTFScenegraph = class {
+    // internal
+    gltf;
+    sourceBuffers;
+    byteLength;
+    // TODO - why is this not GLTFWithBuffers - what happens to images?
     constructor(gltf) {
       this.gltf = {
         json: gltf?.json || makeDefaultGLTFJson(),
@@ -893,6 +938,7 @@ var __exports__ = (() => {
         this.sourceBuffers = [this.gltf.buffers[0]];
       }
     }
+    // Accessors
     get json() {
       return this.gltf.json;
     }
@@ -949,6 +995,9 @@ var __exports__ = (() => {
     getAccessor(index) {
       return this.getObject("accessors", index);
     }
+    // getCamera(index: number): object | null {
+    //   return null; // TODO: fix thi: object  as null;
+    // }
     getTexture(index) {
       return this.getObject("textures", index);
     }
@@ -974,6 +1023,10 @@ var __exports__ = (() => {
       }
       return object;
     }
+    /**
+     * Accepts buffer view index or buffer view object
+     * @returns a `Uint8Array`
+     */
     getTypedArrayForBufferView(bufferView) {
       bufferView = this.getBufferView(bufferView);
       const bufferIndex = bufferView.buffer;
@@ -982,10 +1035,16 @@ var __exports__ = (() => {
       const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
       return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
     }
+    /** Accepts accessor index or accessor object
+     * @returns a typed array with type that matches the types
+     */
     getTypedArrayForAccessor(accessor) {
       const gltfAccessor = this.getAccessor(accessor);
       return getTypedArrayForAccessor(this.gltf.json, this.gltf.buffers, gltfAccessor);
     }
+    /** accepts accessor index or accessor object
+     * returns a `Uint8Array`
+     */
     getTypedArrayForImageData(image) {
       image = this.getAccessor(image);
       const bufferView = this.getBufferView(image.bufferView);
@@ -994,10 +1053,17 @@ var __exports__ = (() => {
       const byteOffset = bufferView.byteOffset || 0;
       return new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
     }
+    // MODIFERS
+    /**
+     * Add an extra application-defined key to the top-level data structure
+     */
     addApplicationData(key, data) {
       this.json[key] = data;
       return this;
     }
+    /**
+     * `extras` - Standard GLTF field for storing application specific data
+     */
     addExtraData(key, data) {
       this.json.extras = this.json.extras || {};
       this.json.extras[key] = data;
@@ -1024,6 +1090,9 @@ var __exports__ = (() => {
       }
       delete extensions[extensionName];
     }
+    /**
+     * Add to standard GLTF top level extension object, mark as used
+     */
     addExtension(extensionName, extensionData = {}) {
       assert3(extensionData);
       this.json.extensions = this.json.extensions || {};
@@ -1031,18 +1100,27 @@ var __exports__ = (() => {
       this.registerUsedExtension(extensionName);
       return extensionData;
     }
+    /**
+     * Standard GLTF top level extension object, mark as used and required
+     */
     addRequiredExtension(extensionName, extensionData = {}) {
       assert3(extensionData);
       this.addExtension(extensionName, extensionData);
       this.registerRequiredExtension(extensionName);
       return extensionData;
     }
+    /**
+     * Add extensionName to list of used extensions
+     */
     registerUsedExtension(extensionName) {
       this.json.extensionsUsed = this.json.extensionsUsed || [];
       if (!this.json.extensionsUsed.find((ext) => ext === extensionName)) {
         this.json.extensionsUsed.push(extensionName);
       }
     }
+    /**
+     * Add extensionName to list of required extensions
+     */
     registerRequiredExtension(extensionName) {
       this.registerUsedExtension(extensionName);
       this.json.extensionsRequired = this.json.extensionsRequired || [];
@@ -1050,6 +1128,9 @@ var __exports__ = (() => {
         this.json.extensionsRequired.push(extensionName);
       }
     }
+    /**
+     * Removes an extension from the top-level list
+     */
     removeExtension(extensionName) {
       if (this.json.extensions?.[extensionName]) {
         this.json.extensionsRemoved = this.json.extensionsRemoved || [];
@@ -1068,47 +1149,49 @@ var __exports__ = (() => {
         this._removeStringFromArray(this.json.extensionsUsed, extensionName);
       }
     }
+    /**
+     *  Set default scene which is to be displayed at load time
+     */
     setDefaultScene(sceneIndex) {
       this.json.scene = sceneIndex;
     }
+    /**
+     * @todo: add more properties for scene initialization:
+     *   name`, `extensions`, `extras`
+     *   https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-scene
+     */
     addScene(scene) {
-      const {
-        nodeIndices
-      } = scene;
+      const { nodeIndices } = scene;
       this.json.scenes = this.json.scenes || [];
-      this.json.scenes.push({
-        nodes: nodeIndices
-      });
+      this.json.scenes.push({ nodes: nodeIndices });
       return this.json.scenes.length - 1;
     }
+    /**
+     * @todo: add more properties for node initialization:
+     *   `name`, `extensions`, `extras`, `camera`, `children`, `skin`, `rotation`, `scale`, `translation`, `weights`
+     *   https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#node
+     */
     addNode(node2) {
-      const {
-        meshIndex,
-        matrix
-      } = node2;
+      const { meshIndex, matrix } = node2;
       this.json.nodes = this.json.nodes || [];
-      const nodeData = {
-        mesh: meshIndex
-      };
+      const nodeData = { mesh: meshIndex };
       if (matrix) {
         nodeData.matrix = matrix;
       }
       this.json.nodes.push(nodeData);
       return this.json.nodes.length - 1;
     }
+    /** Adds a mesh to the json part */
     addMesh(mesh) {
-      const {
-        attributes,
-        indices,
-        material,
-        mode = 4
-      } = mesh;
+      const { attributes, indices, material, mode = 4 } = mesh;
       const accessors = this._addAttributes(attributes);
       const glTFMesh = {
-        primitives: [{
-          attributes: accessors,
-          mode
-        }]
+        primitives: [
+          {
+            attributes: accessors,
+            mode
+          }
+        ]
       };
       if (indices) {
         const indicesAccessor = this._addIndices(indices);
@@ -1124,15 +1207,25 @@ var __exports__ = (() => {
     addPointCloud(attributes) {
       const accessorIndices = this._addAttributes(attributes);
       const glTFMesh = {
-        primitives: [{
-          attributes: accessorIndices,
-          mode: 0
-        }]
+        primitives: [
+          {
+            attributes: accessorIndices,
+            mode: 0
+            // GL.POINTS
+          }
+        ]
       };
       this.json.meshes = this.json.meshes || [];
       this.json.meshes.push(glTFMesh);
       return this.json.meshes.length - 1;
     }
+    /**
+     * Adds a binary image. Builds glTF "JSON metadata" and saves buffer reference
+     * Buffer will be copied into BIN chunk during "pack"
+     * Currently encodes as glTF image
+     * @param imageData
+     * @param mimeType
+     */
     addImage(imageData, mimeTypeOpt) {
       const metadata = getBinaryImageMetadata(imageData);
       const mimeType = mimeTypeOpt || metadata?.mimeType;
@@ -1145,6 +1238,10 @@ var __exports__ = (() => {
       this.json.images.push(glTFImage);
       return this.json.images.length - 1;
     }
+    /**
+     * Add one untyped source buffer, create a matching glTF `bufferView`, and return its index
+     * @param buffer
+     */
     addBufferView(buffer, bufferIndex = 0, byteOffset = this.byteLength) {
       const byteLength = buffer.byteLength;
       assert3(Number.isFinite(byteLength));
@@ -1152,6 +1249,7 @@ var __exports__ = (() => {
       this.sourceBuffers.push(buffer);
       const glTFBufferView = {
         buffer: bufferIndex,
+        // Write offset from the start of the binary body
         byteOffset,
         byteLength
       };
@@ -1160,43 +1258,61 @@ var __exports__ = (() => {
       this.json.bufferViews.push(glTFBufferView);
       return this.json.bufferViews.length - 1;
     }
+    /**
+     * Adds an accessor to a bufferView
+     * @param bufferViewIndex
+     * @param accessor
+     */
     addAccessor(bufferViewIndex, accessor) {
       const glTFAccessor = {
         bufferView: bufferViewIndex,
+        // @ts-ignore
         type: getAccessorTypeFromSize(accessor.size),
+        // @ts-ignore
         componentType: accessor.componentType,
+        // @ts-ignore
         count: accessor.count,
+        // @ts-ignore
         max: accessor.max,
+        // @ts-ignore
         min: accessor.min
       };
       this.json.accessors = this.json.accessors || [];
       this.json.accessors.push(glTFAccessor);
       return this.json.accessors.length - 1;
     }
-    addBinaryBuffer(sourceBuffer, accessor = {
-      size: 3
-    }) {
+    /**
+     * Add a binary buffer. Builds glTF "JSON metadata" and saves buffer reference
+     * Buffer will be copied into BIN chunk during "pack"
+     * Currently encodes buffers as glTF accessors, but this could be optimized
+     * @param sourceBuffer
+     * @param accessor
+     */
+    addBinaryBuffer(sourceBuffer, accessor = { size: 3 }) {
       const bufferViewIndex = this.addBufferView(sourceBuffer);
-      let minMax = {
-        min: accessor.min,
-        max: accessor.max
-      };
+      let minMax = { min: accessor.min, max: accessor.max };
       if (!minMax.min || !minMax.max) {
         minMax = this._getAccessorMinMax(sourceBuffer, accessor.size);
       }
       const accessorDefaults = {
+        // @ts-ignore
         size: accessor.size,
         componentType: getComponentTypeFromArray(sourceBuffer),
+        // @ts-ignore
         count: Math.round(sourceBuffer.length / accessor.size),
         min: minMax.min,
         max: minMax.max
       };
       return this.addAccessor(bufferViewIndex, Object.assign(accessorDefaults, accessor));
     }
+    /**
+     * Adds a texture to the json part
+     * @todo: add more properties for texture initialization
+     * `sampler`, `name`, `extensions`, `extras`
+     * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#texture
+     */
     addTexture(texture) {
-      const {
-        imageIndex
-      } = texture;
+      const { imageIndex } = texture;
       const glTFTexture = {
         source: imageIndex
       };
@@ -1204,11 +1320,13 @@ var __exports__ = (() => {
       this.json.textures.push(glTFTexture);
       return this.json.textures.length - 1;
     }
+    /** Adds a material to the json part */
     addMaterial(pbrMaterialInfo) {
       this.json.materials = this.json.materials || [];
       this.json.materials.push(pbrMaterialInfo);
       return this.json.materials.length - 1;
     }
+    /** Pack the binary chunk */
     createBinaryChunk() {
       this.gltf.buffers = [];
       const totalByteLength = this.byteLength;
@@ -1221,13 +1339,12 @@ var __exports__ = (() => {
       if (this.json?.buffers?.[0]) {
         this.json.buffers[0].byteLength = totalByteLength;
       } else {
-        this.json.buffers = [{
-          byteLength: totalByteLength
-        }];
+        this.json.buffers = [{ byteLength: totalByteLength }];
       }
       this.gltf.binary = arrayBuffer;
       this.sourceBuffers = [arrayBuffer];
     }
+    // PRIVATE
     _removeStringFromArray(array, string) {
       let found = true;
       while (found) {
@@ -1239,6 +1356,9 @@ var __exports__ = (() => {
         }
       }
     }
+    /**
+     * Add attributes to buffers and create `attributes` object which is part of `mesh`
+     */
     _addAttributes(attributes = {}) {
       const result = {};
       for (const attributeKey in attributes) {
@@ -1249,11 +1369,15 @@ var __exports__ = (() => {
       }
       return result;
     }
+    /**
+     * Add indices to buffers
+     */
     _addIndices(indices) {
-      return this.addBinaryBuffer(indices, {
-        size: 1
-      });
+      return this.addBinaryBuffer(indices, { size: 1 });
     }
+    /**
+     * Deduce gltf specific attribue name from input attribute name
+     */
     _getGltfAttributeName(attributeName) {
       switch (attributeName.toLowerCase()) {
         case "position":
@@ -1273,11 +1397,12 @@ var __exports__ = (() => {
           return attributeName;
       }
     }
+    /**
+     * Calculate `min` and `max` arrays of accessor according to spec:
+     * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-accessor
+     */
     _getAccessorMinMax(buffer, size) {
-      const result = {
-        min: null,
-        max: null
-      };
+      const result = { min: null, max: null };
       if (buffer.length < size) {
         return result;
       }
@@ -1290,8 +1415,16 @@ var __exports__ = (() => {
       }
       for (let index = size; index < buffer.length; index += size) {
         for (let componentIndex = 0; componentIndex < size; componentIndex++) {
-          result.min[0 + componentIndex] = Math.min(result.min[0 + componentIndex], buffer[index + componentIndex]);
-          result.max[0 + componentIndex] = Math.max(result.max[0 + componentIndex], buffer[index + componentIndex]);
+          result.min[0 + componentIndex] = Math.min(
+            // @ts-ignore
+            result.min[0 + componentIndex],
+            buffer[index + componentIndex]
+          );
+          result.max[0 + componentIndex] = Math.max(
+            // @ts-ignore
+            result.max[0 + componentIndex],
+            buffer[index + componentIndex]
+          );
         }
       }
       return result;
@@ -1346,7 +1479,14 @@ var __exports__ = (() => {
       return null;
     }
     const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(bufferViewIndex);
-    const arrayOffsets = convertRawBufferToMetadataArray(arrayOffsetsBytes, "SCALAR", offsetType, numberOfElements + 1);
+    const arrayOffsets = convertRawBufferToMetadataArray(
+      arrayOffsetsBytes,
+      "SCALAR",
+      // offsets consist of ONE component
+      offsetType,
+      numberOfElements + 1
+      // The number of offsets is equal to the property table `count` plus one.
+    );
     if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {
       return null;
     }
@@ -1380,7 +1520,13 @@ var __exports__ = (() => {
       if (parsedImage && typeof parsedImage.width !== "undefined") {
         const textureData = [];
         for (let index = 0; index < textureCoordinates.length; index += 2) {
-          const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, textureInfo.channels);
+          const value = getImageValueByCoordinates(
+            parsedImage,
+            mimeType,
+            textureCoordinates,
+            index,
+            textureInfo.channels
+          );
           textureData.push(value);
         }
         return textureData;
@@ -1416,22 +1562,10 @@ var __exports__ = (() => {
   }
   function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels = [0]) {
     const CHANNELS_MAP = {
-      r: {
-        offset: 0,
-        shift: 0
-      },
-      g: {
-        offset: 1,
-        shift: 8
-      },
-      b: {
-        offset: 2,
-        shift: 16
-      },
-      a: {
-        offset: 3,
-        shift: 24
-      }
+      r: { offset: 0, shift: 0 },
+      g: { offset: 1, shift: 8 },
+      b: { offset: 2, shift: 16 },
+      a: { offset: 3, shift: 24 }
     };
     const u = textureCoordinates[index];
     const v = textureCoordinates[index + 1];
@@ -1565,7 +1699,9 @@ var __exports__ = (() => {
     if (!options.gltf?.loadBuffers) {
       return;
     }
-    const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
+    const extension = scenegraph.getExtension(
+      EXT_STRUCTURAL_METADATA_NAME
+    );
     if (!extension) {
       return;
     }
@@ -1641,11 +1777,21 @@ var __exports__ = (() => {
         textureInfoTopLevel.data = [];
       }
       const featureTextureTable = textureInfoTopLevel.data;
-      const propertyData = getPrimitiveTextureData(scenegraph, textureInfoTopLevel, primitive);
+      const propertyData = getPrimitiveTextureData(
+        scenegraph,
+        textureInfoTopLevel,
+        primitive
+      );
       if (propertyData === null) {
         continue;
       }
-      primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTextureTable, primitive);
+      primitivePropertyDataToAttributes(
+        scenegraph,
+        attributeName,
+        propertyData,
+        featureTextureTable,
+        primitive
+      );
       textureInfoTopLevel.data = featureTextureTable;
       extension.dataAttributeNames.push(attributeName);
     }
@@ -1653,14 +1799,22 @@ var __exports__ = (() => {
   function processPropertyTable(scenegraph, schema, propertyTable) {
     const schemaClass = schema.classes?.[propertyTable.class];
     if (!schemaClass) {
-      throw new Error(`Incorrect data in the EXT_structural_metadata extension: no schema class with name ${propertyTable.class}`);
+      throw new Error(
+        `Incorrect data in the EXT_structural_metadata extension: no schema class with name ${propertyTable.class}`
+      );
     }
     const numberOfElements = propertyTable.count;
     for (const propertyName in schemaClass.properties) {
       const classProperty = schemaClass.properties[propertyName];
       const propertyTableProperty = propertyTable.properties?.[propertyName];
       if (propertyTableProperty) {
-        const data = getPropertyDataFromBinarySource(scenegraph, schema, classProperty, numberOfElements, propertyTableProperty);
+        const data = getPropertyDataFromBinarySource(
+          scenegraph,
+          schema,
+          classProperty,
+          numberOfElements,
+          propertyTableProperty
+        );
         propertyTableProperty.data = data;
       }
     }
@@ -1669,8 +1823,17 @@ var __exports__ = (() => {
     let data = [];
     const valuesBufferView = propertyTableProperty.values;
     const valuesDataBytes = scenegraph.getTypedArrayForBufferView(valuesBufferView);
-    const arrayOffsets = getArrayOffsetsForProperty(scenegraph, classProperty, propertyTableProperty, numberOfElements);
-    const stringOffsets = getStringOffsetsForProperty(scenegraph, propertyTableProperty, numberOfElements);
+    const arrayOffsets = getArrayOffsetsForProperty(
+      scenegraph,
+      classProperty,
+      propertyTableProperty,
+      numberOfElements
+    );
+    const stringOffsets = getStringOffsetsForProperty(
+      scenegraph,
+      propertyTableProperty,
+      numberOfElements
+    );
     switch (classProperty.type) {
       case "SCALAR":
       case "VEC2":
@@ -1690,7 +1853,13 @@ var __exports__ = (() => {
         break;
       }
       case "ENUM": {
-        data = getPropertyDataENUM(schema, classProperty, numberOfElements, valuesDataBytes, arrayOffsets);
+        data = getPropertyDataENUM(
+          schema,
+          classProperty,
+          numberOfElements,
+          valuesDataBytes,
+          arrayOffsets
+        );
         break;
       }
       default:
@@ -1699,14 +1868,27 @@ var __exports__ = (() => {
     return data;
   }
   function getArrayOffsetsForProperty(scenegraph, classProperty, propertyTableProperty, numberOfElements) {
-    if (classProperty.array && typeof classProperty.count === "undefined" && typeof propertyTableProperty.arrayOffsets !== "undefined") {
-      return getOffsetsForProperty(scenegraph, propertyTableProperty.arrayOffsets, propertyTableProperty.arrayOffsetType || "UINT32", numberOfElements);
+    if (classProperty.array && // `count` is a number of array elements. May only be defined when `array` is true.
+    // If `count` is NOT defined, it's a VARIABLE-length array
+    typeof classProperty.count === "undefined" && // `arrayOffsets` is an index of the buffer view containing offsets for variable-length arrays.
+    typeof propertyTableProperty.arrayOffsets !== "undefined") {
+      return getOffsetsForProperty(
+        scenegraph,
+        propertyTableProperty.arrayOffsets,
+        propertyTableProperty.arrayOffsetType || "UINT32",
+        numberOfElements
+      );
     }
     return null;
   }
   function getStringOffsetsForProperty(scenegraph, propertyTableProperty, numberOfElements) {
     if (typeof propertyTableProperty.stringOffsets !== "undefined") {
-      return getOffsetsForProperty(scenegraph, propertyTableProperty.stringOffsets, propertyTableProperty.stringOffsetType || "UINT32", numberOfElements);
+      return getOffsetsForProperty(
+        scenegraph,
+        propertyTableProperty.stringOffsets,
+        propertyTableProperty.stringOffsetType || "UINT32",
+        numberOfElements
+      );
     }
     return null;
   }
@@ -1717,13 +1899,25 @@ var __exports__ = (() => {
     const elementCount = valuesDataBytes.byteLength / elementSize;
     let valuesData;
     if (classProperty.componentType) {
-      valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, classProperty.componentType, elementCount);
+      valuesData = convertRawBufferToMetadataArray(
+        valuesDataBytes,
+        classProperty.type,
+        // The datatype of the element's components. Only applicable to `SCALAR`, `VECN`, and `MATN` types.
+        classProperty.componentType,
+        elementCount
+      );
     } else {
       valuesData = valuesDataBytes;
     }
     if (isArray2) {
       if (arrayOffsets) {
-        return parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
+        return parseVariableLengthArrayNumeric(
+          valuesData,
+          numberOfElements,
+          arrayOffsets,
+          valuesDataBytes.length,
+          elementSize
+        );
       }
       if (arrayCount) {
         return parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
@@ -1735,16 +1929,25 @@ var __exports__ = (() => {
   function getPropertyDataENUM(schema, classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
     const enumType = classProperty.enumType;
     if (!enumType) {
-      throw new Error("Incorrect data in the EXT_structural_metadata extension: classProperty.enumType is not set for type ENUM");
+      throw new Error(
+        "Incorrect data in the EXT_structural_metadata extension: classProperty.enumType is not set for type ENUM"
+      );
     }
     const enumEntry = schema.enums?.[enumType];
     if (!enumEntry) {
-      throw new Error(`Incorrect data in the EXT_structural_metadata extension: schema.enums does't contain ${enumType}`);
+      throw new Error(
+        `Incorrect data in the EXT_structural_metadata extension: schema.enums does't contain ${enumType}`
+      );
     }
     const enumValueType = enumEntry.valueType || "UINT16";
     const elementSize = getArrayElementByteSize(classProperty.type, enumValueType);
     const elementCount = valuesDataBytes.byteLength / elementSize;
-    let valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, enumValueType, elementCount);
+    let valuesData = convertRawBufferToMetadataArray(
+      valuesDataBytes,
+      classProperty.type,
+      enumValueType,
+      elementCount
+    );
     if (!valuesData) {
       valuesData = valuesDataBytes;
     }
@@ -1856,9 +2059,7 @@ var __exports__ = (() => {
       return;
     }
     const schemaClasses = schema.classes;
-    const {
-      featureTextures
-    } = extension;
+    const { featureTextures } = extension;
     if (schemaClasses && featureTextures) {
       for (const schemaName in schemaClasses) {
         const schemaClass = schemaClasses[schemaName];
@@ -1909,14 +2110,22 @@ var __exports__ = (() => {
     }
     const schemaClass = schema.classes?.[propertyTable.class];
     if (!schemaClass) {
-      throw new Error(`Incorrect data in the EXT_structural_metadata extension: no schema class with name ${propertyTable.class}`);
+      throw new Error(
+        `Incorrect data in the EXT_structural_metadata extension: no schema class with name ${propertyTable.class}`
+      );
     }
     const numberOfElements = propertyTable.count;
     for (const propertyName in schemaClass.properties) {
       const classProperty = schemaClass.properties[propertyName];
       const propertyTableProperty = propertyTable.properties?.[propertyName];
       if (propertyTableProperty) {
-        const data = getPropertyDataFromBinarySource2(scenegraph, schema, classProperty, numberOfElements, propertyTableProperty);
+        const data = getPropertyDataFromBinarySource2(
+          scenegraph,
+          schema,
+          classProperty,
+          numberOfElements,
+          propertyTableProperty
+        );
         propertyTableProperty.data = data;
       }
     }
@@ -1935,8 +2144,18 @@ var __exports__ = (() => {
     let data = [];
     const bufferView = featureTableProperty.bufferView;
     const dataArray = scenegraph.getTypedArrayForBufferView(bufferView);
-    const arrayOffsets = getArrayOffsetsForProperty2(scenegraph, classProperty, featureTableProperty, numberOfFeatures);
-    const stringOffsets = getStringOffsetsForProperty2(scenegraph, classProperty, featureTableProperty, numberOfFeatures);
+    const arrayOffsets = getArrayOffsetsForProperty2(
+      scenegraph,
+      classProperty,
+      featureTableProperty,
+      numberOfFeatures
+    );
+    const stringOffsets = getStringOffsetsForProperty2(
+      scenegraph,
+      classProperty,
+      featureTableProperty,
+      numberOfFeatures
+    );
     if (classProperty.type === "STRING" || classProperty.componentType === "STRING") {
       data = getPropertyDataString(numberOfFeatures, dataArray, arrayOffsets, stringOffsets);
     } else if (isNumericProperty(classProperty)) {
@@ -1945,19 +2164,44 @@ var __exports__ = (() => {
     return data;
   }
   function getArrayOffsetsForProperty2(scenegraph, classProperty, propertyTableProperty, numberOfElements) {
-    if (classProperty.type === "ARRAY" && typeof classProperty.componentCount === "undefined" && typeof propertyTableProperty.arrayOffsetBufferView !== "undefined") {
-      return getOffsetsForProperty(scenegraph, propertyTableProperty.arrayOffsetBufferView, propertyTableProperty.offsetType || "UINT32", numberOfElements);
+    if (classProperty.type === "ARRAY" && // `componentCount` is a number of fixed-length array elements.
+    // If `componentCount` is NOT defined, it's a VARIABLE-length array
+    typeof classProperty.componentCount === "undefined" && // `arrayOffsetBufferView` is an index of the buffer view containing offsets for variable-length arrays.
+    typeof propertyTableProperty.arrayOffsetBufferView !== "undefined") {
+      return getOffsetsForProperty(
+        scenegraph,
+        propertyTableProperty.arrayOffsetBufferView,
+        propertyTableProperty.offsetType || "UINT32",
+        // offsetType is used both for stringOffsetBufferView and arrayOffsetBufferView
+        numberOfElements
+      );
     }
     return null;
   }
   function getStringOffsetsForProperty2(scenegraph, classProperty, propertyTableProperty, numberOfElements) {
     if (typeof propertyTableProperty.stringOffsetBufferView !== "undefined") {
-      return getOffsetsForProperty(scenegraph, propertyTableProperty.stringOffsetBufferView, propertyTableProperty.offsetType || "UINT32", numberOfElements);
+      return getOffsetsForProperty(
+        scenegraph,
+        propertyTableProperty.stringOffsetBufferView,
+        propertyTableProperty.offsetType || "UINT32",
+        // offsetType is used both for stringOffsetBufferView and arrayOffsetBufferView
+        numberOfElements
+      );
     }
     return null;
   }
   function isNumericProperty(schemaProperty) {
-    const types = ["UINT8", "INT16", "UINT16", "INT32", "UINT32", "INT64", "UINT64", "FLOAT32", "FLOAT64"];
+    const types = [
+      "UINT8",
+      "INT16",
+      "UINT16",
+      "INT32",
+      "UINT32",
+      "INT64",
+      "UINT64",
+      "FLOAT32",
+      "FLOAT64"
+    ];
     return types.includes(schemaProperty.type) || typeof schemaProperty.componentType !== "undefined" && types.includes(schemaProperty.componentType);
   }
   function getPropertyDataNumeric2(classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
@@ -1967,10 +2211,21 @@ var __exports__ = (() => {
     const componentType = classProperty.componentType || classProperty.type;
     const elementSize = getArrayElementByteSize(attributeType, componentType);
     const elementCount = valuesDataBytes.byteLength / elementSize;
-    const valuesData = convertRawBufferToMetadataArray(valuesDataBytes, attributeType, componentType, elementCount);
+    const valuesData = convertRawBufferToMetadataArray(
+      valuesDataBytes,
+      attributeType,
+      componentType,
+      elementCount
+    );
     if (isArray2) {
       if (arrayOffsets) {
-        return parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
+        return parseVariableLengthArrayNumeric(
+          valuesData,
+          numberOfElements,
+          arrayOffsets,
+          valuesDataBytes.length,
+          elementSize
+        );
       }
       if (arrayCount) {
         return parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
@@ -1987,7 +2242,13 @@ var __exports__ = (() => {
     const featureTextureTable = [];
     for (const mesh of json.meshes) {
       for (const primitive of mesh.primitives) {
-        processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive);
+        processPrimitiveTextures(
+          scenegraph,
+          attributeName,
+          featureTextureProperty,
+          featureTextureTable,
+          primitive
+        );
       }
     }
     return featureTextureTable;
@@ -1997,24 +2258,38 @@ var __exports__ = (() => {
       channels: featureTextureProperty.channels,
       ...featureTextureProperty.texture
     };
-    const propertyData = getPrimitiveTextureData(scenegraph, textureInfoTopLevel, primitive);
+    const propertyData = getPrimitiveTextureData(
+      scenegraph,
+      textureInfoTopLevel,
+      primitive
+    );
     if (!propertyData) {
       return;
     }
-    primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTextureTable, primitive);
+    primitivePropertyDataToAttributes(
+      scenegraph,
+      attributeName,
+      propertyData,
+      featureTextureTable,
+      primitive
+    );
   }
 
   // src/lib/utils/version.ts
-  var VERSION3 = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION4 = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // ../textures/src/lib/parsers/basis-module-loader.ts
   var BASIS_EXTERNAL_LIBRARIES = {
+    /** Basis transcoder, javascript wrapper part */
     TRANSCODER: "basis_transcoder.js",
+    /** Basis transcoder, compiled web assembly part */
     TRANSCODER_WASM: "basis_transcoder.wasm",
+    /** Basis encoder, javascript wrapper part */
     ENCODER: "basis_encoder.js",
+    /** Basis encoder, compiled web assembly part */
     ENCODER_WASM: "basis_encoder.wasm"
   };
   var loadBasisTranscoderPromise;
@@ -2029,7 +2304,10 @@ var __exports__ = (() => {
   async function loadBasisTranscoder(options) {
     let BASIS = null;
     let wasmBinary = null;
-    [BASIS, wasmBinary] = await Promise.all([await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER, "textures", options), await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER_WASM, "textures", options)]);
+    [BASIS, wasmBinary] = await Promise.all([
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER, "textures", options),
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER_WASM, "textures", options)
+    ]);
     BASIS = BASIS || globalThis.BASIS;
     return await initializeBasisTranscoderModule(BASIS, wasmBinary);
   }
@@ -2040,14 +2318,9 @@ var __exports__ = (() => {
     }
     return new Promise((resolve) => {
       BasisModule(options).then((module) => {
-        const {
-          BasisFile,
-          initializeBasis
-        } = module;
+        const { BasisFile, initializeBasis } = module;
         initializeBasis();
-        resolve({
-          BasisFile
-        });
+        resolve({ BasisFile });
       });
     });
   }
@@ -2063,7 +2336,10 @@ var __exports__ = (() => {
   async function loadBasisEncoder(options) {
     let BASIS_ENCODER = null;
     let wasmBinary = null;
-    [BASIS_ENCODER, wasmBinary] = await Promise.all([await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER, "textures", options), await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER_WASM, "textures", options)]);
+    [BASIS_ENCODER, wasmBinary] = await Promise.all([
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER, "textures", options),
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER_WASM, "textures", options)
+    ]);
     BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
     return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
   }
@@ -2074,28 +2350,21 @@ var __exports__ = (() => {
     }
     return new Promise((resolve) => {
       BasisEncoderModule(options).then((module) => {
-        const {
-          BasisFile,
-          KTX2File,
-          initializeBasis,
-          BasisEncoder
-        } = module;
+        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
         initializeBasis();
-        resolve({
-          BasisFile,
-          KTX2File,
-          BasisEncoder
-        });
+        resolve({ BasisFile, KTX2File, BasisEncoder });
       });
     });
   }
 
   // ../textures/src/lib/gl-extensions.ts
   var GL_EXTENSIONS_CONSTANTS = {
+    // WEBGL_compressed_texture_s3tc
     COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
     COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
     COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
     COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
+    // WEBGL_compressed_texture_es3
     COMPRESSED_R11_EAC: 37488,
     COMPRESSED_SIGNED_R11_EAC: 37489,
     COMPRESSED_RG11_EAC: 37490,
@@ -2106,14 +2375,18 @@ var __exports__ = (() => {
     COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37495,
     COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37496,
     COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37497,
+    // WEBGL_compressed_texture_pvrtc
     COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
     COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
     COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
     COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
+    // WEBGL_compressed_texture_etc1
     COMPRESSED_RGB_ETC1_WEBGL: 36196,
+    // WEBGL_compressed_texture_atc
     COMPRESSED_RGB_ATC_WEBGL: 35986,
     COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35987,
     COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798,
+    // WEBGL_compressed_texture_astc
     COMPRESSED_RGBA_ASTC_4X4_KHR: 37808,
     COMPRESSED_RGBA_ASTC_5X4_KHR: 37809,
     COMPRESSED_RGBA_ASTC_5X5_KHR: 37810,
@@ -2142,10 +2415,12 @@ var __exports__ = (() => {
     COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR: 37851,
     COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR: 37852,
     COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR: 37853,
+    // EXT_texture_compression_rgtc
     COMPRESSED_RED_RGTC1_EXT: 36283,
     COMPRESSED_SIGNED_RED_RGTC1_EXT: 36284,
     COMPRESSED_RED_GREEN_RGTC2_EXT: 36285,
     COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 36286,
+    // WEBGL_compressed_texture_s3tc_srgb
     COMPRESSED_SRGB_S3TC_DXT1_EXT: 35916,
     COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 35917,
     COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 35918,
@@ -2155,6 +2430,7 @@ var __exports__ = (() => {
   // ../textures/src/lib/utils/texture-formats.ts
   var BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
   var WEBGL_EXTENSIONS = {
+    /* eslint-disable camelcase */
     WEBGL_compressed_texture_s3tc: "dxt",
     WEBGL_compressed_texture_s3tc_srgb: "dxt-srgb",
     WEBGL_compressed_texture_etc1: "etc1",
@@ -2163,6 +2439,7 @@ var __exports__ = (() => {
     WEBGL_compressed_texture_atc: "atc",
     WEBGL_compressed_texture_astc: "astc",
     EXT_texture_compression_rgtc: "rgtc"
+    /* eslint-enable camelcase */
   };
   var formats = null;
   function getSupportedGPUTextureFormats(gl) {
@@ -2218,10 +2495,35 @@ var __exports__ = (() => {
   }(f || (f = {}));
 
   // ../textures/src/lib/parsers/parse-ktx.ts
-  var KTX2_ID = [171, 75, 84, 88, 32, 50, 48, 187, 13, 10, 26, 10];
+  var KTX2_ID = [
+    // '´', 'K', 'T', 'X', '2', '0', 'ª', '\r', '\n', '\x1A', '\n'
+    171,
+    75,
+    84,
+    88,
+    32,
+    50,
+    48,
+    187,
+    13,
+    10,
+    26,
+    10
+  ];
   function isKTX(data) {
     const id = new Uint8Array(data);
-    const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || id[1] !== KTX2_ID[1] || id[2] !== KTX2_ID[2] || id[3] !== KTX2_ID[3] || id[4] !== KTX2_ID[4] || id[5] !== KTX2_ID[5] || id[6] !== KTX2_ID[6] || id[7] !== KTX2_ID[7] || id[8] !== KTX2_ID[8] || id[9] !== KTX2_ID[9] || id[10] !== KTX2_ID[10] || id[11] !== KTX2_ID[11];
+    const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || // '´'
+    id[1] !== KTX2_ID[1] || // 'K'
+    id[2] !== KTX2_ID[2] || // 'T'
+    id[3] !== KTX2_ID[3] || // 'X'
+    id[4] !== KTX2_ID[4] || // ' '
+    id[5] !== KTX2_ID[5] || // '2'
+    id[6] !== KTX2_ID[6] || // '0'
+    id[7] !== KTX2_ID[7] || // 'ª'
+    id[8] !== KTX2_ID[8] || // '\r'
+    id[9] !== KTX2_ID[9] || // '\n'
+    id[10] !== KTX2_ID[10] || // '\x1A'
+    id[11] !== KTX2_ID[11];
     return !notKTX;
   }
 
@@ -2232,10 +2534,7 @@ var __exports__ = (() => {
       compressed: true,
       format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
     },
-    etc2: {
-      basisFormat: 1,
-      compressed: true
-    },
+    etc2: { basisFormat: 1, compressed: true },
     bc1: {
       basisFormat: 2,
       compressed: true,
@@ -2246,22 +2545,10 @@ var __exports__ = (() => {
       compressed: true,
       format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT
     },
-    bc4: {
-      basisFormat: 4,
-      compressed: true
-    },
-    bc5: {
-      basisFormat: 5,
-      compressed: true
-    },
-    "bc7-m6-opaque-only": {
-      basisFormat: 6,
-      compressed: true
-    },
-    "bc7-m5": {
-      basisFormat: 7,
-      compressed: true
-    },
+    bc4: { basisFormat: 4, compressed: true },
+    bc5: { basisFormat: 5, compressed: true },
+    "bc7-m6-opaque-only": { basisFormat: 6, compressed: true },
+    "bc7-m5": { basisFormat: 7, compressed: true },
     "pvrtc1-4-rgb": {
       basisFormat: 8,
       compressed: true,
@@ -2277,30 +2564,12 @@ var __exports__ = (() => {
       compressed: true,
       format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR
     },
-    "atc-rgb": {
-      basisFormat: 11,
-      compressed: true
-    },
-    "atc-rgba-interpolated-alpha": {
-      basisFormat: 12,
-      compressed: true
-    },
-    rgba32: {
-      basisFormat: 13,
-      compressed: false
-    },
-    rgb565: {
-      basisFormat: 14,
-      compressed: false
-    },
-    bgr565: {
-      basisFormat: 15,
-      compressed: false
-    },
-    rgba4444: {
-      basisFormat: 16,
-      compressed: false
-    }
+    "atc-rgb": { basisFormat: 11, compressed: true },
+    "atc-rgba-interpolated-alpha": { basisFormat: 12, compressed: true },
+    rgba32: { basisFormat: 13, compressed: false },
+    rgb565: { basisFormat: 14, compressed: false },
+    bgr565: { basisFormat: 15, compressed: false },
+    rgba4444: { basisFormat: 16, compressed: false }
   };
   async function parseBasis(data, options) {
     if (options.basis.containerFormat === "auto") {
@@ -2308,9 +2577,7 @@ var __exports__ = (() => {
         const fileConstructors = await loadBasisEncoderModule(options);
         return parseKTX2File(fileConstructors.KTX2File, data, options);
       }
-      const {
-        BasisFile
-      } = await loadBasisTranscoderModule(options);
+      const { BasisFile } = await loadBasisTranscoderModule(options);
       return parseBasisFile(BasisFile, data, options);
     }
     switch (options.basis.module) {
@@ -2325,9 +2592,7 @@ var __exports__ = (() => {
         }
       case "transcoder":
       default:
-        const {
-          BasisFile
-        } = await loadBasisTranscoderModule(options);
+        const { BasisFile } = await loadBasisTranscoderModule(options);
         return parseBasisFile(BasisFile, data, options);
     }
   }
@@ -2356,23 +2621,24 @@ var __exports__ = (() => {
   function transcodeImage(basisFile, imageIndex, levelIndex, options) {
     const width = basisFile.getImageWidth(imageIndex, levelIndex);
     const height = basisFile.getImageHeight(imageIndex, levelIndex);
-    const hasAlpha = basisFile.getHasAlpha();
-    const {
-      compressed,
-      format,
-      basisFormat
-    } = getBasisOptions(options, hasAlpha);
+    const hasAlpha = basisFile.getHasAlpha(
+      /* imageIndex, levelIndex */
+    );
+    const { compressed, format, basisFormat } = getBasisOptions(options, hasAlpha);
     const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
     const decodedData = new Uint8Array(decodedSize);
     if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
       throw new Error("failed to start Basis transcoding");
     }
     return {
+      // standard loaders.gl image category payload
       width,
       height,
       data: decodedData,
       compressed,
       format,
+      // Additional fields
+      // Add levelSize field.
       hasAlpha
     };
   }
@@ -2395,26 +2661,35 @@ var __exports__ = (() => {
     }
   }
   function transcodeKTX2Image(ktx2File, levelIndex, options) {
-    const {
-      alphaFlag,
-      height,
-      width
-    } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
-    const {
-      compressed,
-      format,
+    const { alphaFlag, height, width } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
+    const { compressed, format, basisFormat } = getBasisOptions(options, alphaFlag);
+    const decodedSize = ktx2File.getImageTranscodedSizeInBytes(
+      levelIndex,
+      0,
+      0,
       basisFormat
-    } = getBasisOptions(options, alphaFlag);
-    const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0, 0, basisFormat);
+    );
     const decodedData = new Uint8Array(decodedSize);
-    if (!ktx2File.transcodeImage(decodedData, levelIndex, 0, 0, basisFormat, 0, -1, -1)) {
+    if (!ktx2File.transcodeImage(
+      decodedData,
+      levelIndex,
+      0,
+      0,
+      basisFormat,
+      0,
+      -1,
+      -1
+      /* channel1 */
+    )) {
       throw new Error("Failed to transcode KTX2 image");
     }
     return {
+      // standard loaders.gl image category payload
       width,
       height,
       data: decodedData,
       compressed,
+      // Additional fields
       levelSize: decodedSize,
       hasAlpha: alphaFlag,
       format
@@ -2467,9 +2742,12 @@ var __exports__ = (() => {
     options: {
       basis: {
         format: "auto",
+        // gl context doesn't exist on a worker thread
         libraryPath: "libs/",
         containerFormat: "auto",
+        // 'basis' || 'ktx2' || 'auto'
         module: "transcoder"
+        // 'transcoder' || 'encoder'
       }
     }
   };
@@ -2493,9 +2771,7 @@ var __exports__ = (() => {
   }
   function isGLB(arrayBuffer, byteOffset = 0, options = {}) {
     const dataView = new DataView(arrayBuffer);
-    const {
-      magic = MAGIC_glTF
-    } = options;
+    const { magic = MAGIC_glTF } = options;
     const magic1 = dataView.getUint32(byteOffset, false);
     return magic1 === magic || magic1 === MAGIC_glTF;
   }
@@ -2505,8 +2781,10 @@ var __exports__ = (() => {
     const version = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
     const byteLength = dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN2);
     Object.assign(glb, {
+      // Put less important stuff in a header, to avoid clutter
       header: {
         byteOffset,
+        // Byte offset into the initial arrayBuffer
         byteLength,
         hasBinChunk: false
       },
@@ -2583,6 +2861,7 @@ var __exports__ = (() => {
       byteOffset,
       byteLength: chunkLength,
       arrayBuffer: dataView.buffer
+      // TODO - copy, or create typed array view?
     });
     return padToNBytes(chunkLength, 4);
   }
@@ -2610,29 +2889,154 @@ var __exports__ = (() => {
   // src/meshopt/meshopt-decoder.ts
   var wasm_base = "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";
   var wasm_simd = "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";
-  var detector = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 5, 3, 1, 0, 1, 12, 1, 0, 10, 22, 2, 12, 0, 65, 0, 65, 0, 65, 0, 252, 10, 0, 0, 11, 7, 0, 65, 0, 253, 15, 26, 11]);
-  var wasmpack = new Uint8Array([32, 0, 65, 253, 3, 1, 2, 34, 4, 106, 6, 5, 11, 8, 7, 20, 13, 33, 12, 16, 128, 9, 116, 64, 19, 113, 127, 15, 10, 21, 22, 14, 255, 66, 24, 54, 136, 107, 18, 23, 192, 26, 114, 118, 132, 17, 77, 101, 130, 144, 27, 87, 131, 44, 45, 74, 156, 154, 70, 167]);
+  var detector = new Uint8Array([
+    0,
+    97,
+    115,
+    109,
+    1,
+    0,
+    0,
+    0,
+    1,
+    4,
+    1,
+    96,
+    0,
+    0,
+    3,
+    3,
+    2,
+    0,
+    0,
+    5,
+    3,
+    1,
+    0,
+    1,
+    12,
+    1,
+    0,
+    10,
+    22,
+    2,
+    12,
+    0,
+    65,
+    0,
+    65,
+    0,
+    65,
+    0,
+    252,
+    10,
+    0,
+    0,
+    11,
+    7,
+    0,
+    65,
+    0,
+    253,
+    15,
+    26,
+    11
+  ]);
+  var wasmpack = new Uint8Array([
+    32,
+    0,
+    65,
+    253,
+    3,
+    1,
+    2,
+    34,
+    4,
+    106,
+    6,
+    5,
+    11,
+    8,
+    7,
+    20,
+    13,
+    33,
+    12,
+    16,
+    128,
+    9,
+    116,
+    64,
+    19,
+    113,
+    127,
+    15,
+    10,
+    21,
+    22,
+    14,
+    255,
+    66,
+    24,
+    54,
+    136,
+    107,
+    18,
+    23,
+    192,
+    26,
+    114,
+    118,
+    132,
+    17,
+    77,
+    101,
+    130,
+    144,
+    27,
+    87,
+    131,
+    44,
+    45,
+    74,
+    156,
+    154,
+    70,
+    167
+  ]);
   var FILTERS = {
+    // legacy index-based enums for glTF
     0: "",
     1: "meshopt_decodeFilterOct",
     2: "meshopt_decodeFilterQuat",
     3: "meshopt_decodeFilterExp",
+    // string-based enums for glTF
     NONE: "",
     OCTAHEDRAL: "meshopt_decodeFilterOct",
     QUATERNION: "meshopt_decodeFilterQuat",
     EXPONENTIAL: "meshopt_decodeFilterExp"
   };
   var DECODERS = {
+    // legacy index-based enums for glTF
     0: "meshopt_decodeVertexBuffer",
     1: "meshopt_decodeIndexBuffer",
     2: "meshopt_decodeIndexSequence",
+    // string-based enums for glTF
     ATTRIBUTES: "meshopt_decodeVertexBuffer",
     TRIANGLES: "meshopt_decodeIndexBuffer",
     INDICES: "meshopt_decodeIndexSequence"
   };
   async function meshoptDecodeGltfBuffer(target, count, size, source, mode, filter = "NONE") {
     const instance = await loadWasmInstance();
-    decode4(instance, instance.exports[DECODERS[mode]], target, count, size, source, instance.exports[FILTERS[filter || "NONE"]]);
+    decode4(
+      instance,
+      instance.exports[DECODERS[mode]],
+      target,
+      count,
+      size,
+      source,
+      instance.exports[FILTERS[filter || "NONE"]]
+    );
   }
   var wasmPromise;
   async function loadWasmInstance() {
@@ -2697,7 +3101,10 @@ var __exports__ = (() => {
     scenegraph.removeExtension(EXT_MESHOPT_COMPRESSION);
   }
   async function decodeMeshoptBufferView(scenegraph, bufferView) {
-    const meshoptExtension = scenegraph.getObjectExtension(bufferView, EXT_MESHOPT_COMPRESSION);
+    const meshoptExtension = scenegraph.getObjectExtension(
+      bufferView,
+      EXT_MESHOPT_COMPRESSION
+    );
     if (meshoptExtension) {
       const {
         byteOffset = 0,
@@ -2710,7 +3117,11 @@ var __exports__ = (() => {
       } = meshoptExtension;
       const buffer = scenegraph.gltf.buffers[bufferIndex];
       const source = new Uint8Array(buffer.arrayBuffer, buffer.byteOffset + byteOffset, byteLength);
-      const result = new Uint8Array(scenegraph.gltf.buffers[bufferView.buffer].arrayBuffer, bufferView.byteOffset, bufferView.byteLength);
+      const result = new Uint8Array(
+        scenegraph.gltf.buffers[bufferView.buffer].arrayBuffer,
+        bufferView.byteOffset,
+        bufferView.byteLength
+      );
       await meshoptDecodeGltfBuffer(result, count, byteStride, source, mode, filter);
       scenegraph.removeObjectExtension(bufferView, EXT_MESHOPT_COMPRESSION);
     }
@@ -2732,11 +3143,12 @@ var __exports__ = (() => {
       }
       return;
     }
-    const {
-      json
-    } = scenegraph;
+    const { json } = scenegraph;
     for (const texture of json.textures || []) {
-      const extension = scenegraph.getObjectExtension(texture, EXT_TEXTURE_WEBP);
+      const extension = scenegraph.getObjectExtension(
+        texture,
+        EXT_TEXTURE_WEBP
+      );
       if (extension) {
         texture.source = extension.source;
       }
@@ -2755,11 +3167,12 @@ var __exports__ = (() => {
   var name6 = KHR_TEXTURE_BASISU;
   function preprocess2(gltfData, options) {
     const scene = new GLTFScenegraph(gltfData);
-    const {
-      json
-    } = scene;
+    const { json } = scene;
     for (const texture of json.textures || []) {
-      const extension = scene.getObjectExtension(texture, KHR_TEXTURE_BASISU);
+      const extension = scene.getObjectExtension(
+        texture,
+        KHR_TEXTURE_BASISU
+      );
       if (extension) {
         texture.source = extension.source;
         scene.removeObjectExtension(texture, KHR_TEXTURE_BASISU);
@@ -2778,13 +3191,14 @@ var __exports__ = (() => {
   });
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION5 = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // ../draco/src/draco-loader.ts
   var DracoLoader = {
     name: "Draco",
     id: "draco",
     module: "draco",
+    // shapes: ['mesh'],
     version: VERSION5,
     worker: true,
     extensions: ["drc"],
@@ -2794,6 +3208,7 @@ var __exports__ = (() => {
     options: {
       draco: {
         decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
+        // 'js' for IE11
         libraryPath: "libs/",
         extraAttributes: {},
         attributeNameEntry: void 0
@@ -2847,7 +3262,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
@@ -2856,14 +3274,7 @@ var __exports__ = (() => {
     const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
     return {
       name: name12,
-      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
     };
@@ -2889,17 +3300,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 = {};
@@ -2941,15 +3353,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);
@@ -2994,6 +3418,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);
@@ -3006,6 +3438,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++) {
@@ -3033,6 +3471,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;
@@ -3045,6 +3489,7 @@ var __exports__ = (() => {
             return {
               topology: "triangle-strip",
               mode: 4,
+              // GL.TRIANGLES
               attributes,
               indices: {
                 value: this._getTriangleStripIndices(dracoGeometry),
@@ -3056,6 +3501,7 @@ var __exports__ = (() => {
             return {
               topology: "triangle-list",
               mode: 5,
+              // GL.TRIANGLE_STRIP
               attributes,
               indices: {
                 value: this._getTriangleListIndices(dracoGeometry),
@@ -3067,6 +3513,7 @@ var __exports__ = (() => {
       return {
         topology: "point-list",
         mode: 0,
+        // GL.POINTS
         attributes
       };
     }
@@ -3075,10 +3522,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,
@@ -3089,6 +3533,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;
@@ -3101,6 +3550,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 {
@@ -3110,6 +3563,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;
@@ -3121,19 +3580,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;
         }
@@ -3151,14 +3639,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 {};
@@ -3171,6 +3667,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 {
@@ -3186,20 +3687,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) {
@@ -3219,9 +3721,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) {
@@ -3238,6 +3738,7 @@ var __exports__ = (() => {
       }
       return null;
     }
+    // HELPERS
   };
   function getDracoDataType(draco, attributeType) {
     switch (attributeType) {
@@ -3281,9 +3782,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 = {
@@ -3297,9 +3802,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);
@@ -3311,11 +3814,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);
@@ -3328,9 +3849,8 @@ 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.
       });
     });
   }
@@ -3341,9 +3861,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);
@@ -3365,14 +3883,16 @@ var __exports__ = (() => {
     return accessors;
   }
   function getGLTFAccessor(attribute) {
-    const {
-      buffer,
-      size,
-      count
-    } = getAccessorData(attribute);
+    const { buffer, size, count } = getAccessorData(attribute);
     const glTFAccessor = {
+      // glTF Accessor values
+      // TODO: Instead of a bufferView index we could have an actual buffer (typed array)
+      // bufferView: null,
+      // TODO: Deprecate `value` in favor of bufferView?
+      // @ts-ignore
       value: buffer,
       size,
+      // Decoded `type` (e.g. SCALAR)
       byteOffset: 0,
       count,
       type: getAccessorTypeFromSize(size),
@@ -3394,11 +3914,7 @@ var __exports__ = (() => {
       }
       count = buffer.length / size;
     }
-    return {
-      buffer,
-      size,
-      count
-    };
+    return { buffer, size, count };
   }
   function toTypedArray(array, ArrayType, convertTypedArrays = false) {
     if (!array) {
@@ -3445,15 +3961,16 @@ var __exports__ = (() => {
     }
   }
   async function decompressPrimitive(scenegraph, primitive, options, context) {
-    const dracoExtension = scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION);
+    const dracoExtension = scenegraph.getObjectExtension(
+      primitive,
+      KHR_DRACO_MESH_COMPRESSION
+    );
     if (!dracoExtension) {
       return;
     }
     const buffer = scenegraph.getTypedArrayForBufferView(dracoExtension.bufferView);
     const bufferCopy = sliceArrayBuffer(buffer.buffer, buffer.byteOffset);
-    const dracoOptions = {
-      ...options
-    };
+    const dracoOptions = { ...options };
     delete dracoOptions["3d-tiles"];
     const decodedData = await parseFromContext(bufferCopy, DracoLoader2, dracoOptions, context);
     const decodedAttributes = getGLTFAccessors(decodedData.attributes);
@@ -3478,25 +3995,26 @@ var __exports__ = (() => {
     if (!options.DracoWriter) {
       throw new Error("options.gltf.DracoWriter not provided");
     }
-    const compressedData = options.DracoWriter.encodeSync({
-      attributes
-    });
-    const decodedData = context?.parseSync?.({
-      attributes
-    });
+    const compressedData = options.DracoWriter.encodeSync({ attributes });
+    const decodedData = context?.parseSync?.({ attributes });
     const fauxAccessors = options._addFauxAttributes(decodedData.attributes);
     const bufferViewIndex = options.addBufferView(compressedData);
     const glTFMesh = {
-      primitives: [{
-        attributes: fauxAccessors,
-        mode,
-        extensions: {
-          [KHR_DRACO_MESH_COMPRESSION]: {
-            bufferView: bufferViewIndex,
-            attributes: fauxAccessors
+      primitives: [
+        {
+          attributes: fauxAccessors,
+          // TODO - verify with spec
+          mode,
+          // GL.POINTS
+          extensions: {
+            [KHR_DRACO_MESH_COMPRESSION]: {
+              bufferView: bufferViewIndex,
+              attributes: fauxAccessors
+              // TODO - verify with spec
+            }
           }
         }
-      }]
+      ]
     };
     return glTFMesh;
   }
@@ -4675,14 +5193,14 @@ var __exports__ = (() => {
   }
 
   // src/lib/extensions/KHR_texture_transform.ts
-  var EXT_MESHOPT_TRANSFORM = "KHR_texture_transform";
-  var name8 = EXT_MESHOPT_TRANSFORM;
+  var KHR_TEXTURE_TRANSFORM = "KHR_texture_transform";
+  var name8 = KHR_TEXTURE_TRANSFORM;
   var scratchVector = new Vector3();
   var scratchRotationMatrix = new Matrix3();
   var scratchScaleMatrix = new Matrix3();
   async function decode7(gltfData, options) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
-    const hasExtension = gltfScenegraph.hasExtension(EXT_MESHOPT_TRANSFORM);
+    const hasExtension = gltfScenegraph.hasExtension(KHR_TEXTURE_TRANSFORM);
     if (!hasExtension || !options.gltf?.loadBuffers) {
       return;
     }
@@ -4692,27 +5210,19 @@ var __exports__ = (() => {
     }
   }
   function transformTexCoords(materialIndex, gltfData) {
-    const processedTexCoords = [];
     const material = gltfData.json.materials?.[materialIndex];
-    const baseColorTexture = material?.pbrMetallicRoughness?.baseColorTexture;
-    if (baseColorTexture) {
-      transformPrimitives(gltfData, materialIndex, baseColorTexture, processedTexCoords);
-    }
-    const emisiveTexture = material?.emissiveTexture;
-    if (emisiveTexture) {
-      transformPrimitives(gltfData, materialIndex, emisiveTexture, processedTexCoords);
-    }
-    const normalTexture = material?.normalTexture;
-    if (normalTexture) {
-      transformPrimitives(gltfData, materialIndex, normalTexture, processedTexCoords);
-    }
-    const occlusionTexture = material?.occlusionTexture;
-    if (occlusionTexture) {
-      transformPrimitives(gltfData, materialIndex, occlusionTexture, processedTexCoords);
-    }
-    const metallicRoughnessTexture = material?.pbrMetallicRoughness?.metallicRoughnessTexture;
-    if (metallicRoughnessTexture) {
-      transformPrimitives(gltfData, materialIndex, metallicRoughnessTexture, processedTexCoords);
+    const materialTextures = [
+      material?.pbrMetallicRoughness?.baseColorTexture,
+      material?.emissiveTexture,
+      material?.normalTexture,
+      material?.occlusionTexture,
+      material?.pbrMetallicRoughness?.metallicRoughnessTexture
+    ];
+    const processedTexCoords = [];
+    for (const textureInfo of materialTextures) {
+      if (textureInfo && textureInfo?.extensions?.[KHR_TEXTURE_TRANSFORM]) {
+        transformPrimitives(gltfData, materialIndex, textureInfo, processedTexCoords);
+      }
     }
   }
   function transformPrimitives(gltfData, materialIndex, texture, processedTexCoords) {
@@ -4731,49 +5241,33 @@ var __exports__ = (() => {
     }
   }
   function getTransformParameters(texture, processedTexCoords) {
-    const textureInfo = texture.extensions?.[EXT_MESHOPT_TRANSFORM];
-    const {
-      texCoord: originalTexCoord = 0
-    } = texture;
-    const {
-      texCoord = originalTexCoord
-    } = textureInfo;
-    const isProcessed = processedTexCoords.findIndex(([original, newTexCoord]) => original === originalTexCoord && newTexCoord === texCoord) !== -1;
+    const textureInfo = texture.extensions?.[KHR_TEXTURE_TRANSFORM];
+    const { texCoord: originalTexCoord = 0 } = texture;
+    const { texCoord = originalTexCoord } = textureInfo;
+    const isProcessed = processedTexCoords.findIndex(
+      ([original, newTexCoord]) => original === originalTexCoord && newTexCoord === texCoord
+    ) !== -1;
     if (!isProcessed) {
       const matrix = makeTransformationMatrix(textureInfo);
       if (originalTexCoord !== texCoord) {
         texture.texCoord = texCoord;
       }
       processedTexCoords.push([originalTexCoord, texCoord]);
-      return {
-        originalTexCoord,
-        texCoord,
-        matrix
-      };
+      return { originalTexCoord, texCoord, matrix };
     }
     return null;
   }
   function transformPrimitive(gltfData, primitive, transformParameters) {
-    const {
-      originalTexCoord,
-      texCoord,
-      matrix
-    } = transformParameters;
+    const { originalTexCoord, texCoord, matrix } = transformParameters;
     const texCoordAccessor = primitive.attributes[`TEXCOORD_${originalTexCoord}`];
     if (Number.isFinite(texCoordAccessor)) {
       const accessor = gltfData.json.accessors?.[texCoordAccessor];
       if (accessor && accessor.bufferView) {
         const bufferView = gltfData.json.bufferViews?.[accessor.bufferView];
         if (bufferView) {
-          const {
-            arrayBuffer,
-            byteOffset: bufferByteOffset
-          } = gltfData.buffers[bufferView.buffer];
+          const { arrayBuffer, byteOffset: bufferByteOffset } = gltfData.buffers[bufferView.buffer];
           const byteOffset = (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);
-          const {
-            ArrayType,
-            length
-          } = getAccessorArrayTypeAndLength(accessor, bufferView);
+          const { ArrayType, length } = getAccessorArrayTypeAndLength(accessor, bufferView);
           const bytes = BYTES[accessor.componentType];
           const components = COMPONENTS[accessor.type];
           const elementAddressScale = bufferView.byteStride || bytes * components;
@@ -4834,13 +5328,19 @@ var __exports__ = (() => {
     primitive.attributes[`TEXCOORD_${newTexCoord}`] = accessors.length - 1;
   }
   function makeTransformationMatrix(extensionData) {
-    const {
-      offset = [0, 0],
-      rotation = 0,
-      scale: scale2 = [1, 1]
-    } = extensionData;
+    const { offset = [0, 0], rotation = 0, scale: scale2 = [1, 1] } = extensionData;
     const translationMatrix = new Matrix3().set(1, 0, 0, 0, 1, 0, offset[0], offset[1], 1);
-    const rotationMatrix = scratchRotationMatrix.set(Math.cos(rotation), Math.sin(rotation), 0, -Math.sin(rotation), Math.cos(rotation), 0, 0, 0, 1);
+    const rotationMatrix = scratchRotationMatrix.set(
+      Math.cos(rotation),
+      Math.sin(rotation),
+      0,
+      -Math.sin(rotation),
+      Math.cos(rotation),
+      0,
+      0,
+      0,
+      1
+    );
     const scaleMatrix = scratchScaleMatrix.set(scale2[0], 0, 0, 0, scale2[1], 0, 0, 0, 1);
     return translationMatrix.multiplyRight(rotationMatrix).multiplyRight(scaleMatrix);
   }
@@ -4856,9 +5356,7 @@ var __exports__ = (() => {
   var name9 = KHR_LIGHTS_PUNCTUAL;
   async function decode8(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
-    const {
-      json
-    } = gltfScenegraph;
+    const { json } = gltfScenegraph;
     const extension = gltfScenegraph.getExtension(KHR_LIGHTS_PUNCTUAL);
     if (extension) {
       gltfScenegraph.json.lights = extension.lights;
@@ -4874,9 +5372,7 @@ var __exports__ = (() => {
   }
   async function encode2(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
-    const {
-      json
-    } = gltfScenegraph;
+    const { json } = gltfScenegraph;
     if (json.lights) {
       const extension = gltfScenegraph.addExtension(KHR_LIGHTS_PUNCTUAL);
       assert3(!extension.lights);
@@ -4903,9 +5399,7 @@ var __exports__ = (() => {
   var name10 = KHR_MATERIALS_UNLIT;
   async function decode9(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
-    const {
-      json
-    } = gltfScenegraph;
+    const { json } = gltfScenegraph;
     for (const material of json.materials || []) {
       const extension = material.extensions && material.extensions.KHR_materials_unlit;
       if (extension) {
@@ -4917,9 +5411,7 @@ var __exports__ = (() => {
   }
   function encode3(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
-    const {
-      json
-    } = gltfScenegraph;
+    const { json } = gltfScenegraph;
     if (gltfScenegraph.materials) {
       for (const material of json.materials || []) {
         if (material.unlit) {
@@ -4942,16 +5434,19 @@ var __exports__ = (() => {
   var name11 = KHR_TECHNIQUES_WEBGL;
   async function decode10(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
-    const {
-      json
-    } = gltfScenegraph;
+    const { json } = gltfScenegraph;
     const extension = gltfScenegraph.getExtension(KHR_TECHNIQUES_WEBGL);
     if (extension) {
       const techniques = resolveTechniques(extension, gltfScenegraph);
       for (const material of json.materials || []) {
         const materialExtension = gltfScenegraph.getObjectExtension(material, KHR_TECHNIQUES_WEBGL);
         if (materialExtension) {
-          material.technique = Object.assign({}, materialExtension, techniques[materialExtension.technique]);
+          material.technique = Object.assign(
+            {},
+            materialExtension,
+            // @ts-ignore
+            techniques[materialExtension.technique]
+          );
           material.technique.values = resolveValues(material.technique, gltfScenegraph);
         }
         gltfScenegraph.removeObjectExtension(material, KHR_TECHNIQUES_WEBGL);
@@ -4962,15 +5457,13 @@ var __exports__ = (() => {
   async function encode4(gltfData, options) {
   }
   function resolveTechniques(techniquesExtension, gltfScenegraph) {
-    const {
-      programs = [],
-      shaders = [],
-      techniques = []
-    } = techniquesExtension;
+    const { programs = [], shaders = [], techniques = [] } = techniquesExtension;
     const textDecoder = new TextDecoder();
     shaders.forEach((shader) => {
       if (Number.isFinite(shader.bufferView)) {
-        shader.code = textDecoder.decode(gltfScenegraph.getTypedArrayForBufferView(shader.bufferView));
+        shader.code = textDecoder.decode(
+          gltfScenegraph.getTypedArrayForBufferView(shader.bufferView)
+        );
       } else {
         throw new Error("KHR_techniques_webgl: no shader code");
       }
@@ -5000,7 +5493,24 @@ var __exports__ = (() => {
   }
 
   // src/lib/api/gltf-extensions.ts
-  var EXTENSIONS2 = [EXT_structural_metadata_exports, EXT_mesh_features_exports, EXT_meshopt_compression_exports, EXT_texture_webp_exports, KHR_texture_basisu_exports, KHR_draco_mesh_compression_exports, KHR_lights_punctual_exports, KHR_materials_unlit_exports, KHR_techniques_webgl_exports, KHR_texture_transform_exports, EXT_feature_metadata_exports];
+  var EXTENSIONS2 = [
+    // 1.0
+    // KHR_binary_gltf is handled separately - must be processed before other parsing starts
+    // KHR_binary_gltf,
+    // 2.0
+    EXT_structural_metadata_exports,
+    EXT_mesh_features_exports,
+    EXT_meshopt_compression_exports,
+    EXT_texture_webp_exports,
+    // Basisu should come after webp, we want basisu to be preferred if both are provided
+    KHR_texture_basisu_exports,
+    KHR_draco_mesh_compression_exports,
+    KHR_lights_punctual_exports,
+    KHR_materials_unlit_exports,
+    KHR_techniques_webgl_exports,
+    KHR_texture_transform_exports,
+    EXT_feature_metadata_exports
+  ];
   function preprocessExtensions(gltf, options = {}, context) {
     const extensions = EXTENSIONS2.filter((extension) => useExtension(extension.name, options));
     for (const extension of extensions) {
@@ -5023,11 +5533,12 @@ var __exports__ = (() => {
   var KHR_BINARY_GLTF = "KHR_binary_glTF";
   function preprocess4(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
-    const {
-      json
-    } = gltfScenegraph;
+    const { json } = gltfScenegraph;
     for (const image of json.images || []) {
-      const extension = gltfScenegraph.getObjectExtension(image, KHR_BINARY_GLTF);
+      const extension = gltfScenegraph.getObjectExtension(
+        image,
+        KHR_BINARY_GLTF
+      );
       if (extension) {
         Object.assign(image, extension);
       }
@@ -5083,6 +5594,14 @@ var __exports__ = (() => {
       skins: {},
       textures: {}
     };
+    json;
+    // constructor() {}
+    /**
+     * Convert (normalize) glTF < 2.0 to glTF 2.0
+     * @param gltf - object with json and binChunks
+     * @param options
+     * @param options normalize Whether to actually normalize
+     */
     normalize(gltf, options) {
       this.json = gltf.json;
       const json = gltf.json;
@@ -5107,6 +5626,7 @@ var __exports__ = (() => {
       this._updateObjects(json);
       this._updateMaterial(json);
     }
+    // asset is now required, #642 https://github.com/KhronosGroup/glTF/issues/639
     _addAsset(json) {
       json.asset = json.asset || {};
       json.asset.version = "2.0";
@@ -5117,6 +5637,7 @@ var __exports__ = (() => {
         this._convertTopLevelObjectToArray(json, arrayName);
       }
     }
+    /** Convert one top level object to array */
     _convertTopLevelObjectToArray(json, mapName) {
       const objectMap = json[mapName];
       if (!objectMap || Array.isArray(objectMap)) {
@@ -5131,6 +5652,7 @@ var __exports__ = (() => {
         this.idToIndexMap[mapName][id] = index;
       }
     }
+    /** Go through all objects in all top-level arrays and replace ids with indices */
     _convertObjectIdsToArrayIndices(json) {
       for (const arrayName in GLTF_ARRAYS) {
         this._convertIdsToIndices(json, arrayName);
@@ -5158,11 +5680,7 @@ var __exports__ = (() => {
     }
     _convertMeshIds(mesh) {
       for (const primitive of mesh.primitives) {
-        const {
-          attributes,
-          indices,
-          material
-        } = primitive;
+        const { attributes, indices, material } = primitive;
         for (const attributeName in attributes) {
           attributes[attributeName] = this._convertIdToIndex(attributes[attributeName], "accessor");
         }
@@ -5187,6 +5705,7 @@ var __exports__ = (() => {
         scene.nodes = scene.nodes.map((node2) => this._convertIdToIndex(node2, "node"));
       }
     }
+    /** Go through all objects in a top-level array and replace ids with indices */
     _convertIdsToIndices(json, topLevelArrayName) {
       if (!json[topLevelArrayName]) {
         console.warn(`gltf v1: json doesn't contain attribute ${topLevelArrayName}`);
@@ -5211,11 +5730,19 @@ var __exports__ = (() => {
       }
       return id;
     }
+    /**
+     *
+     * @param {*} json
+     */
     _updateObjects(json) {
       for (const buffer of this.json.buffers) {
         delete buffer.type;
       }
     }
+    /**
+     * Update material (set pbrMetallicRoughness)
+     * @param {*} json
+     */
     _updateMaterial(json) {
       for (const material of json.materials) {
         material.pbrMetallicRoughness = {
@@ -5226,9 +5753,7 @@ var __exports__ = (() => {
         const textureId = material.values?.tex || material.values?.texture2d_0 || material.values?.diffuseTex;
         const textureIndex = json.textures.findIndex((texture) => texture.id === textureId);
         if (textureIndex !== -1) {
-          material.pbrMetallicRoughness.baseColorTexture = {
-            index: textureIndex
-          };
+          material.pbrMetallicRoughness.baseColorTexture = { index: textureIndex };
         }
       }
     }
@@ -5240,9 +5765,7 @@ var __exports__ = (() => {
   // src/lib/parsers/parse-gltf.ts
   async function parseGLTF(gltf, arrayBufferOrString, byteOffset = 0, options, context) {
     parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);
-    normalizeGLTFV1(gltf, {
-      normalize: options?.gltf?.normalize
-    });
+    normalizeGLTFV1(gltf, { normalize: options?.gltf?.normalize });
     preprocessExtensions(gltf, options, context);
     if (options?.gltf?.loadBuffers && gltf.json.buffers) {
       await loadBuffers(gltf, options, context);
@@ -5275,9 +5798,7 @@ var __exports__ = (() => {
     const buffers = gltf.json.buffers || [];
     gltf.buffers = new Array(buffers.length).fill(null);
     if (gltf._glb && gltf._glb.header.hasBinChunk) {
-      const {
-        binChunks
-      } = gltf._glb;
+      const { binChunks } = gltf._glb;
       gltf.buffers[0] = {
         arrayBuffer: binChunks[0].arrayBuffer,
         byteOffset: binChunks[0].byteOffset,
@@ -5292,9 +5813,7 @@ var __exports__ = (() => {
     for (let i2 = 0; i2 < buffers.length; ++i2) {
       const buffer = buffers[i2];
       if (buffer.uri) {
-        const {
-          fetch: fetch2
-        } = context;
+        const { fetch: fetch2 } = context;
         assert3(fetch2);
         const uri = resolveUrl(buffer.uri, options);
         const response = await context?.fetch?.(uri);
@@ -5337,9 +5856,7 @@ var __exports__ = (() => {
     let arrayBuffer;
     if (image.uri && !image.hasOwnProperty("bufferView")) {
       const uri = resolveUrl(image.uri, options);
-      const {
-        fetch: fetch2
-      } = context;
+      const { fetch: fetch2 } = context;
       const response = await fetch2(uri);
       arrayBuffer = await response.arrayBuffer();
       image.bufferView = {
@@ -5351,16 +5868,20 @@ var __exports__ = (() => {
       arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);
     }
     assert3(arrayBuffer, "glTF image has no data");
-    let parsedImage = await parseFromContext(arrayBuffer, [ImageLoader, BasisLoader], {
-      ...options,
-      mimeType: image.mimeType,
-      basis: options.basis || {
-        format: selectSupportedBasisFormat()
-      }
-    }, context);
+    let parsedImage = await parseFromContext(
+      arrayBuffer,
+      [ImageLoader, BasisLoader],
+      {
+        ...options,
+        mimeType: image.mimeType,
+        basis: options.basis || { format: selectSupportedBasisFormat() }
+      },
+      context
+    );
     if (parsedImage && parsedImage[0]) {
       parsedImage = {
         compressed: true,
+        // @ts-expect-error
         mipmaps: false,
         width: parsedImage[0].width,
         height: parsedImage[0].height,
@@ -5386,25 +5907,23 @@ var __exports__ = (() => {
     options: {
       gltf: {
         normalize: true,
+        // Normalize glTF v1 to glTF v2 format (not yet stable)
         loadBuffers: true,
+        // Fetch any linked .BIN buffers, decode base64
         loadImages: true,
+        // Create image objects
         decompressMeshes: true
+        // Decompress Draco encoded meshes
       },
+      // common?
       log: console
+      // eslint-disable-line
     }
   };
   async function parse2(arrayBuffer, options = {}, context) {
-    options = {
-      ...GLTFLoader.options,
-      ...options
-    };
-    options.gltf = {
-      ...GLTFLoader.options.gltf,
-      ...options.gltf
-    };
-    const {
-      byteOffset = 0
-    } = options;
+    options = { ...GLTFLoader.options, ...options };
+    options.gltf = { ...GLTFLoader.options.gltf, ...options.gltf };
+    const { byteOffset = 0 } = options;
     const gltf = {};
     return await parseGLTF(gltf, arrayBuffer, byteOffset, options, context);
   }
@@ -5415,12 +5934,7 @@ var __exports__ = (() => {
   var MAGIC_BIN = 5130562;
   var LE = true;
   function encodeGLBSync(glb, dataView, byteOffset = 0, options = {}) {
-    const {
-      magic = MAGIC_glTF2,
-      version = 2,
-      json = {},
-      binary
-    } = glb;
+    const { magic = MAGIC_glTF2, version = 2, json = {}, binary } = glb;
     const byteOffsetStart = byteOffset;
     if (dataView) {
       dataView.setUint32(byteOffset + 0, magic, LE);
@@ -5466,9 +5980,7 @@ var __exports__ = (() => {
     convertBuffersToBase64(gltf);
     return encodeGLBSync(gltf, arrayBuffer, byteOffset, options);
   }
-  function convertBuffersToBase64(gltf, {
-    firstBuffer = 0
-  } = {}) {
+  function convertBuffersToBase64(gltf, { firstBuffer = 0 } = {}) {
     if (gltf.buffers && gltf.buffers.length > firstBuffer) {
       throw new Error("encodeGLTF: multiple buffers not yet implemented");
     }
@@ -5481,7 +5993,9 @@ var __exports__ = (() => {
     module: "gltf",
     version: VERSION3,
     extensions: ["glb"],
+    // We only support encoding to binary GLB, not to JSON GLTF
     mimeTypes: ["model/gltf-binary"],
+    // 'model/gltf+json',
     binary: true,
     options: {
       gltf: {}
@@ -5490,9 +6004,7 @@ var __exports__ = (() => {
     encodeSync
   };
   function encodeSync(gltf, options = {}) {
-    const {
-      byteOffset = 0
-    } = options;
+    const { byteOffset = 0 } = options;
     const byteLength = encodeGLTFSync(gltf, null, byteOffset, options);
     const arrayBuffer = new ArrayBuffer(byteLength);
     const dataView = new DataView(arrayBuffer);
@@ -5514,6 +6026,7 @@ var __exports__ = (() => {
     options: {
       glb: {
         strict: false
+        // Enables deprecated XVIZ support (illegal CHUNK formats)
       }
     }
   };
@@ -5521,9 +6034,7 @@ var __exports__ = (() => {
     return parseSync(arrayBuffer, options);
   }
   function parseSync(arrayBuffer, options) {
-    const {
-      byteOffset = 0
-    } = options || {};
+    const { byteOffset = 0 } = options || {};
     const glb = {};
     parseGLBSync(glb, arrayBuffer, byteOffset, options?.glb);
     return glb;
@@ -5545,9 +6056,7 @@ var __exports__ = (() => {
     encodeSync: encodeSync2
   };
   function encodeSync2(glb, options) {
-    const {
-      byteOffset = 0
-    } = options;
+    const { byteOffset = 0 } = options;
     const byteLength = encodeGLBSync(glb, null, byteOffset, options);
     const arrayBuffer = new ArrayBuffer(byteLength);
     const dataView = new DataView(arrayBuffer);
@@ -5567,17 +6076,25 @@ var __exports__ = (() => {
   };
   var BYTES2 = {
     5120: 1,
+    // BYTE
     5121: 1,
+    // UNSIGNED_BYTE
     5122: 2,
+    // SHORT
     5123: 2,
+    // UNSIGNED_SHORT
     5125: 4,
+    // UNSIGNED_INT
     5126: 4
+    // FLOAT
   };
   var GL_SAMPLER = {
+    // Sampler parameters
     TEXTURE_MAG_FILTER: 10240,
     TEXTURE_MIN_FILTER: 10241,
     TEXTURE_WRAP_S: 10242,
     TEXTURE_WRAP_T: 10243,
+    // Sampler default values
     REPEAT: 10497,
     LINEAR: 9729,
     NEAREST_MIPMAP_LINEAR: 9986
@@ -5608,17 +6125,15 @@ var __exports__ = (() => {
   }
   var GLTFPostProcessor = class {
     baseUri = "";
+    // @ts-expect-error
+    jsonUnprocessed;
+    // @ts-expect-error
+    json;
     buffers = [];
     images = [];
     postProcess(gltf, options = {}) {
-      const {
-        json,
-        buffers = [],
-        images = []
-      } = gltf;
-      const {
-        baseUri = ""
-      } = gltf;
+      const { json, buffers = [], images = [] } = gltf;
+      const { baseUri = "" } = gltf;
       assert3(json);
       this.baseUri = baseUri;
       this.buffers = buffers;
@@ -5627,10 +6142,11 @@ var __exports__ = (() => {
       this.json = this._resolveTree(gltf.json, options);
       return this.json;
     }
+    // Convert indexed glTF structure into tree structure
+    // cross-link index resolution, enum lookup, convenience calculations
+    // eslint-disable-next-line complexity, max-statements
     _resolveTree(gltf, options = {}) {
-      const json = {
-        ...gltf
-      };
+      const json = { ...gltf };
       this.json = json;
       if (gltf.bufferViews) {
         json.bufferViews = gltf.bufferViews.map((bufView, i2) => this._resolveBufferView(bufView, i2));
@@ -5714,9 +6230,11 @@ var __exports__ = (() => {
       }
       return object;
     }
+    // PARSING HELPERS
     _resolveScene(scene, index) {
       return {
         ...scene,
+        // @ts-ignore
         id: scene.id || `scene-${index}`,
         nodes: (scene.nodes || []).map((node2) => this.getNode(node2))
       };
@@ -5724,6 +6242,7 @@ var __exports__ = (() => {
     _resolveNode(gltfNode, index) {
       const node2 = {
         ...gltfNode,
+        // @ts-expect-error id could already be present, glTF standard does not prevent it
         id: gltfNode?.id || `node-${index}`
       };
       if (gltfNode.mesh !== void 0) {
@@ -5736,14 +6255,15 @@ var __exports__ = (() => {
         node2.skin = this.getSkin(gltfNode.skin);
       }
       if (gltfNode.meshes !== void 0 && gltfNode.meshes.length) {
-        node2.mesh = gltfNode.meshes.reduce((accum, meshIndex) => {
-          const mesh = this.getMesh(meshIndex);
-          accum.id = mesh.id;
-          accum.primitives = accum.primitives.concat(mesh.primitives);
-          return accum;
-        }, {
-          primitives: []
-        });
+        node2.mesh = gltfNode.meshes.reduce(
+          (accum, meshIndex) => {
+            const mesh = this.getMesh(meshIndex);
+            accum.id = mesh.id;
+            accum.primitives = accum.primitives.concat(mesh.primitives);
+            return accum;
+          },
+          { primitives: [] }
+        );
       }
       return node2;
     }
@@ -5793,44 +6313,33 @@ var __exports__ = (() => {
     _resolveMaterial(gltfMaterial, index) {
       const material = {
         ...gltfMaterial,
+        // @ts-expect-error
         id: gltfMaterial.id || `material-${index}`
       };
       if (material.normalTexture) {
-        material.normalTexture = {
-          ...material.normalTexture
-        };
+        material.normalTexture = { ...material.normalTexture };
         material.normalTexture.texture = this.getTexture(material.normalTexture.index);
       }
       if (material.occlusionTexture) {
-        material.occlusionTexture = {
-          ...material.occlusionTexture
-        };
+        material.occlusionTexture = { ...material.occlusionTexture };
         material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);
       }
       if (material.emissiveTexture) {
-        material.emissiveTexture = {
-          ...material.emissiveTexture
-        };
+        material.emissiveTexture = { ...material.emissiveTexture };
         material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);
       }
       if (!material.emissiveFactor) {
         material.emissiveFactor = material.emissiveTexture ? [1, 1, 1] : [0, 0, 0];
       }
       if (material.pbrMetallicRoughness) {
-        material.pbrMetallicRoughness = {
-          ...material.pbrMetallicRoughness
-        };
+        material.pbrMetallicRoughness = { ...material.pbrMetallicRoughness };
         const mr = material.pbrMetallicRoughness;
         if (mr.baseColorTexture) {
-          mr.baseColorTexture = {
-            ...mr.baseColorTexture
-          };
+          mr.baseColorTexture = { ...mr.baseColorTexture };
           mr.baseColorTexture.texture = this.getTexture(mr.baseColorTexture.index);
         }
         if (mr.metallicRoughnessTexture) {
-          mr.metallicRoughnessTexture = {
-            ...mr.metallicRoughnessTexture
-          };
+          mr.metallicRoughnessTexture = { ...mr.metallicRoughnessTexture };
           mr.metallicRoughnessTexture.texture = this.getTexture(mr.metallicRoughnessTexture.index);
         }
       }
@@ -5842,6 +6351,7 @@ var __exports__ = (() => {
       const bytesPerElement = bytesPerComponent * components;
       const accessor = {
         ...gltfAccessor,
+        // @ts-expect-error
         id: gltfAccessor.id || `accessor-${index}`,
         bytesPerComponent,
         components,
@@ -5855,30 +6365,47 @@ var __exports__ = (() => {
       }
       if (accessor.bufferView) {
         const buffer = accessor.bufferView.buffer;
-        const {
-          ArrayType,
-          byteLength
-        } = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);
+        const { ArrayType, byteLength } = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);
         const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
         let cutBuffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
         if (accessor.bufferView.byteStride) {
-          cutBuffer = this._getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
+          cutBuffer = this._getValueFromInterleavedBuffer(
+            buffer,
+            byteOffset,
+            accessor.bufferView.byteStride,
+            accessor.bytesPerElement,
+            accessor.count
+          );
         }
         accessor.value = new ArrayType(cutBuffer);
       }
       return accessor;
     }
+    /**
+     * Take values of particular accessor from interleaved buffer
+     * various parts of the buffer
+     * @param buffer
+     * @param byteOffset
+     * @param byteStride
+     * @param bytesPerElement
+     * @param count
+     * @returns
+     */
     _getValueFromInterleavedBuffer(buffer, byteOffset, byteStride, bytesPerElement, count) {
       const result = new Uint8Array(count * bytesPerElement);
       for (let i2 = 0; i2 < count; i2++) {
         const elementOffset = byteOffset + i2 * byteStride;
-        result.set(new Uint8Array(buffer.arrayBuffer.slice(elementOffset, elementOffset + bytesPerElement)), i2 * bytesPerElement);
+        result.set(
+          new Uint8Array(buffer.arrayBuffer.slice(elementOffset, elementOffset + bytesPerElement)),
+          i2 * bytesPerElement
+        );
       }
       return result.buffer;
     }
     _resolveTexture(gltfTexture, index) {
       return {
         ...gltfTexture,
+        // @ts-expect-error id could already be present, glTF standard does not prevent it
         id: gltfTexture.id || `texture-${index}`,
         sampler: typeof gltfTexture.sampler === "number" ? this.getSampler(gltfTexture.sampler) : makeDefaultSampler(),
         source: typeof gltfTexture.source === "number" ? this.getImage(gltfTexture.source) : void 0
@@ -5886,6 +6413,7 @@ var __exports__ = (() => {
     }
     _resolveSampler(gltfSampler, index) {
       const sampler = {
+        // @ts-expect-error id could already be present, glTF standard does not prevent it
         id: gltfSampler.id || `sampler-${index}`,
         ...gltfSampler,
         parameters: {}
@@ -5904,6 +6432,7 @@ var __exports__ = (() => {
     _resolveImage(gltfImage, index) {
       const image = {
         ...gltfImage,
+        // @ts-expect-error id could already be present, glTF standard does not prevent it
         id: gltfImage.id || `image-${index}`,
         image: null,
         bufferView: gltfImage.bufferView !== void 0 ? this.getBufferView(gltfImage.bufferView) : void 0
@@ -5922,8 +6451,10 @@ var __exports__ = (() => {
         byteOffset += gltfBufferView.byteOffset;
       }
       const bufferView = {
+        // // @ts-expect-error id could already be present, glTF standard does not prevent it
         id: `bufferView-${index}`,
         ...gltfBufferView,
+        // ...this.buffers[bufferIndex],
         buffer: this.buffers[bufferIndex],
         data: new Uint8Array(arrayBuffer, byteOffset, gltfBufferView.byteLength)
       };
@@ -5932,6 +6463,7 @@ var __exports__ = (() => {
     _resolveCamera(gltfCamera, index) {
       const camera = {
         ...gltfCamera,
+        // @ts-expect-error id could already be present, glTF standard does not prevent it
         id: gltfCamera.id || `camera-${index}`
       };
       if (camera.perspective) {
@@ -5944,7 +6476,7 @@ var __exports__ = (() => {
   function postProcessGLTF(gltf, options) {
     return new GLTFPostProcessor().postProcess(gltf, options);
   }
-  return __toCommonJS(src_exports);
+  return __toCommonJS(bundle_exports);
 })();
       return __exports__;
       });