@loaders.gl/gltf 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/dist.min.js

@@ -14,8 +14,8 @@
   };
   var __export = (target, all) => {
     __markAsModule(target);
-    for (var name8 in all)
-      __defProp(target, name8, { get: all[name8], enumerable: true });
+    for (var name10 in all)
+      __defProp(target, name10, { get: all[name10], enumerable: true });
   };
   var __reExport = (target, module, desc) => {
     if (module && typeof module === "object" || typeof module === "function") {
@@ -37,20 +37,43 @@
     }
   });
 
-  // ../textures/src/lib/utils/version.ts
-  var VERSION2;
-  var init_version2 = __esm({
-    "../textures/src/lib/utils/version.ts"() {
-      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+  // ../loader-utils/src/lib/env-utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loader assertion failed.");
+    }
+  }
+  var init_assert = __esm({
+    "../loader-utils/src/lib/env-utils/assert.ts"() {
+    }
+  });
+
+  // ../loader-utils/src/lib/env-utils/globals.ts
+  var globals, self_, window_, global_, document_, isBrowser, matches, nodeVersion;
+  var init_globals = __esm({
+    "../loader-utils/src/lib/env-utils/globals.ts"() {
+      globals = {
+        self: typeof self !== "undefined" && self,
+        window: typeof window !== "undefined" && window,
+        global: typeof global !== "undefined" && global,
+        document: typeof document !== "undefined" && document
+      };
+      self_ = globals.self || globals.window || globals.global || {};
+      window_ = globals.window || globals.self || globals.global || {};
+      global_ = globals.global || globals.self || globals.window || {};
+      document_ = globals.document || {};
+      isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
+      matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+      nodeVersion = matches && parseFloat(matches[1]) || 0;
     }
   });
 
   // ../worker-utils/src/lib/env-utils/version.ts
-  var DEFAULT_VERSION, VERSION3;
-  var init_version3 = __esm({
+  var DEFAULT_VERSION, VERSION2;
+  var init_version2 = __esm({
     "../worker-utils/src/lib/env-utils/version.ts"() {
       DEFAULT_VERSION = "beta";
-      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : DEFAULT_VERSION;
+      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : DEFAULT_VERSION;
       if (typeof __VERSION__ === "undefined") {
         console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
       }
@@ -58,35 +81,35 @@
   });
 
   // ../worker-utils/src/lib/env-utils/assert.ts
-  function assert(condition, message) {
+  function assert2(condition, message) {
     if (!condition) {
       throw new Error(message || "loaders.gl assertion failed.");
     }
   }
-  var init_assert = __esm({
+  var init_assert2 = __esm({
     "../worker-utils/src/lib/env-utils/assert.ts"() {
     }
   });
 
   // ../worker-utils/src/lib/env-utils/globals.ts
-  var globals, self_, window_, global_, document_, isBrowser, isWorker, isMobile, matches, nodeVersion;
-  var init_globals = __esm({
+  var globals2, self_2, window_2, global_2, document_2, isBrowser2, isWorker, isMobile, matches2, nodeVersion2;
+  var init_globals2 = __esm({
     "../worker-utils/src/lib/env-utils/globals.ts"() {
-      globals = {
+      globals2 = {
         self: typeof self !== "undefined" && self,
         window: typeof window !== "undefined" && window,
         global: typeof global !== "undefined" && global,
         document: typeof document !== "undefined" && document
       };
-      self_ = globals.self || globals.window || globals.global || {};
-      window_ = globals.window || globals.self || globals.global || {};
-      global_ = globals.global || globals.self || globals.window || {};
-      document_ = globals.document || {};
-      isBrowser = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
+      self_2 = globals2.self || globals2.window || globals2.global || {};
+      window_2 = globals2.window || globals2.self || globals2.global || {};
+      global_2 = globals2.global || globals2.self || globals2.window || {};
+      document_2 = globals2.document || {};
+      isBrowser2 = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
       isWorker = typeof importScripts === "function";
       isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
-      matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
-      nodeVersion = matches && parseFloat(matches[1]) || 0;
+      matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+      nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
     }
   });
 
@@ -112,12 +135,12 @@
     if (modules[library]) {
       return modules[library];
     }
-    if (!isBrowser) {
+    if (!isBrowser2) {
       return `modules/${moduleName}/dist/libs/${library}`;
     }
     if (options.CDN) {
-      assert(options.CDN.startsWith("http"));
-      return `${options.CDN}/${moduleName}@${VERSION4}/dist/libs/${library}`;
+      assert2(options.CDN.startsWith("http"));
+      return `${options.CDN}/${moduleName}@${VERSION3}/dist/libs/${library}`;
     }
     if (isWorker) {
       return `../src/libs/${library}`;
@@ -129,7 +152,7 @@
       const response2 = await fetch(libraryUrl);
       return await response2.arrayBuffer();
     }
-    if (!isBrowser) {
+    if (!isBrowser2) {
       try {
         return node && node.requireFromFile && await node.requireFromFile(libraryUrl);
       } catch {
@@ -144,11 +167,11 @@
     return loadLibraryFromString(scriptSource, libraryUrl);
   }
   function loadLibraryFromString(scriptSource, id) {
-    if (!isBrowser) {
+    if (!isBrowser2) {
       return node.requireFromString && node.requireFromString(scriptSource, id);
     }
     if (isWorker) {
-      eval.call(global_, scriptSource);
+      eval.call(global_2, scriptSource);
       return null;
     }
     const script = document.createElement("script");
@@ -161,15 +184,15 @@
     document.body.appendChild(script);
     return null;
   }
-  var node, LATEST, VERSION4, loadLibraryPromises;
+  var node, LATEST, VERSION3, loadLibraryPromises;
   var init_library_utils = __esm({
     "../worker-utils/src/lib/library-utils/library-utils.ts"() {
-      init_globals();
+      init_globals2();
       node = __toModule(require_require_utils());
-      init_assert();
-      init_version3();
+      init_assert2();
+      init_version2();
       LATEST = "beta";
-      VERSION4 = typeof VERSION3 !== "undefined" ? VERSION3 : LATEST;
+      VERSION3 = typeof VERSION2 !== "undefined" ? VERSION2 : LATEST;
       loadLibraryPromises = {};
     }
   });
@@ -177,10 +200,135 @@
   // ../worker-utils/src/index.ts
   var init_src = __esm({
     "../worker-utils/src/index.ts"() {
+      init_globals2();
       init_library_utils();
     }
   });
 
+  // ../loader-utils/src/lib/binary-utils/get-first-characters.ts
+  function getFirstCharacters(data, length = 5) {
+    if (typeof data === "string") {
+      return data.slice(0, length);
+    } else if (ArrayBuffer.isView(data)) {
+      return getMagicString(data.buffer, data.byteOffset, length);
+    } else if (data instanceof ArrayBuffer) {
+      const byteOffset = 0;
+      return getMagicString(data, byteOffset, length);
+    }
+    return "";
+  }
+  function getMagicString(arrayBuffer, byteOffset, length) {
+    if (arrayBuffer.byteLength <= byteOffset + length) {
+      return "";
+    }
+    const dataView = new DataView(arrayBuffer);
+    let magic = "";
+    for (let i2 = 0; i2 < length; i2++) {
+      magic += String.fromCharCode(dataView.getUint8(byteOffset + i2));
+    }
+    return magic;
+  }
+  var init_get_first_characters = __esm({
+    "../loader-utils/src/lib/binary-utils/get-first-characters.ts"() {
+    }
+  });
+
+  // ../loader-utils/src/lib/parser-utils/parse-json.ts
+  function parseJSON(string) {
+    try {
+      return JSON.parse(string);
+    } catch (_) {
+      throw new Error(`Failed to parse JSON from data starting with "${getFirstCharacters(string)}"`);
+    }
+  }
+  var init_parse_json = __esm({
+    "../loader-utils/src/lib/parser-utils/parse-json.ts"() {
+      init_get_first_characters();
+    }
+  });
+
+  // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
+  function sliceArrayBuffer(arrayBuffer, byteOffset, byteLength) {
+    const subArray = byteLength !== void 0 ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength) : new Uint8Array(arrayBuffer).subarray(byteOffset);
+    const arrayCopy = new Uint8Array(subArray);
+    return arrayCopy.buffer;
+  }
+  var init_array_buffer_utils = __esm({
+    "../loader-utils/src/lib/binary-utils/array-buffer-utils.ts"() {
+    }
+  });
+
+  // ../loader-utils/src/lib/binary-utils/memory-copy-utils.ts
+  function padToNBytes(byteLength, padding) {
+    assert(byteLength >= 0);
+    assert(padding > 0);
+    return byteLength + (padding - 1) & ~(padding - 1);
+  }
+  function copyToArray(source, target, targetOffset) {
+    let sourceArray;
+    if (source instanceof ArrayBuffer) {
+      sourceArray = new Uint8Array(source);
+    } else {
+      const srcByteOffset = source.byteOffset;
+      const srcByteLength = source.byteLength;
+      sourceArray = new Uint8Array(source.buffer || source.arrayBuffer, srcByteOffset, srcByteLength);
+    }
+    target.set(sourceArray, targetOffset);
+    return targetOffset + padToNBytes(sourceArray.byteLength, 4);
+  }
+  var init_memory_copy_utils = __esm({
+    "../loader-utils/src/lib/binary-utils/memory-copy-utils.ts"() {
+      init_assert();
+    }
+  });
+
+  // ../loader-utils/src/lib/binary-utils/dataview-copy-utils.ts
+  function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
+    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 sourceArray = new Uint8Array(sourceBuffer);
+      targetArray.set(sourceArray);
+      for (let i2 = 0; i2 < padLength; ++i2) {
+        dataView.setUint8(byteOffset + sourceBuffer.byteLength + i2, 32);
+      }
+    }
+    byteOffset += paddedLength;
+    return byteOffset;
+  }
+  function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
+    const textEncoder = new TextEncoder();
+    const stringBuffer = textEncoder.encode(string);
+    byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);
+    return byteOffset;
+  }
+  var init_dataview_copy_utils = __esm({
+    "../loader-utils/src/lib/binary-utils/dataview-copy-utils.ts"() {
+      init_memory_copy_utils();
+    }
+  });
+
+  // ../loader-utils/src/index.ts
+  var init_src2 = __esm({
+    "../loader-utils/src/index.ts"() {
+      init_assert();
+      init_globals();
+      init_parse_json();
+      init_array_buffer_utils();
+      init_memory_copy_utils();
+      init_dataview_copy_utils();
+    }
+  });
+
+  // ../textures/src/lib/utils/version.ts
+  var VERSION4;
+  var init_version3 = __esm({
+    "../textures/src/lib/utils/version.ts"() {
+      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+    }
+  });
+
   // ../textures/src/lib/parsers/basis-module-loader.ts
   async function loadBasisTrascoderModule(options) {
     const modules = options.modules || {};
@@ -513,6 +661,7 @@
       height,
       data: decodedData,
       compressed,
+      levelSize: decodedSize,
       hasAlpha: alphaFlag,
       format
     };
@@ -606,13 +755,14 @@
   var BasisWorkerLoader, BasisLoader;
   var init_basis_loader = __esm({
     "../textures/src/basis-loader.ts"() {
-      init_version2();
+      init_src();
+      init_version3();
       init_parse_basis();
       BasisWorkerLoader = {
         name: "Basis",
-        id: "basis",
+        id: isBrowser2 ? "basis" : "basis-nodejs",
         module: "textures",
-        version: VERSION2,
+        version: VERSION4,
         worker: true,
         extensions: ["basis", "ktx2"],
         mimeTypes: ["application/octet-stream", "image/ktx2"],
@@ -634,185 +784,38 @@
     }
   });
 
-  // ../loader-utils/src/lib/env-utils/assert.ts
-  function assert2(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loader assertion failed.");
-    }
-  }
-  var init_assert2 = __esm({
-    "../loader-utils/src/lib/env-utils/assert.ts"() {
-    }
-  });
-
-  // ../loader-utils/src/lib/env-utils/globals.ts
-  var globals2, self_2, window_2, global_2, document_2, isBrowser2, matches2, nodeVersion2;
-  var init_globals2 = __esm({
-    "../loader-utils/src/lib/env-utils/globals.ts"() {
-      globals2 = {
-        self: typeof self !== "undefined" && self,
-        window: typeof window !== "undefined" && window,
-        global: typeof global !== "undefined" && global,
-        document: typeof document !== "undefined" && document
-      };
-      self_2 = globals2.self || globals2.window || globals2.global || {};
-      window_2 = globals2.window || globals2.self || globals2.global || {};
-      global_2 = globals2.global || globals2.self || globals2.window || {};
-      document_2 = globals2.document || {};
-      isBrowser2 = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
-      matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
-      nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
+  // ../images/src/lib/utils/version.ts
+  var VERSION6;
+  var init_version4 = __esm({
+    "../images/src/lib/utils/version.ts"() {
+      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
-  // ../loader-utils/src/lib/binary-utils/get-first-characters.ts
-  function getFirstCharacters(data, length = 5) {
-    if (typeof data === "string") {
-      return data.slice(0, length);
-    } else if (ArrayBuffer.isView(data)) {
-      return getMagicString(data.buffer, data.byteOffset, length);
-    } else if (data instanceof ArrayBuffer) {
-      const byteOffset = 0;
-      return getMagicString(data, byteOffset, length);
+  // ../images/src/lib/category-api/image-type.ts
+  function isImageTypeSupported(type) {
+    switch (type) {
+      case "auto":
+        return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;
+      case "imagebitmap":
+        return IMAGE_BITMAP_SUPPORTED;
+      case "image":
+        return IMAGE_SUPPORTED;
+      case "data":
+        return DATA_SUPPORTED;
+      default:
+        throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
     }
-    return "";
   }
-  function getMagicString(arrayBuffer, byteOffset, length) {
-    if (arrayBuffer.byteLength <= byteOffset + length) {
-      return "";
+  function getDefaultImageType() {
+    if (IMAGE_BITMAP_SUPPORTED) {
+      return "imagebitmap";
     }
-    const dataView = new DataView(arrayBuffer);
-    let magic = "";
-    for (let i2 = 0; i2 < length; i2++) {
-      magic += String.fromCharCode(dataView.getUint8(byteOffset + i2));
+    if (IMAGE_SUPPORTED) {
+      return "image";
     }
-    return magic;
-  }
-  var init_get_first_characters = __esm({
-    "../loader-utils/src/lib/binary-utils/get-first-characters.ts"() {
-    }
-  });
-
-  // ../loader-utils/src/lib/parser-utils/parse-json.ts
-  function parseJSON(string) {
-    try {
-      return JSON.parse(string);
-    } catch (_) {
-      throw new Error(`Failed to parse JSON from data starting with "${getFirstCharacters(string)}"`);
-    }
-  }
-  var init_parse_json = __esm({
-    "../loader-utils/src/lib/parser-utils/parse-json.ts"() {
-      init_get_first_characters();
-    }
-  });
-
-  // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
-  function sliceArrayBuffer(arrayBuffer, byteOffset, byteLength) {
-    const subArray = byteLength !== void 0 ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength) : new Uint8Array(arrayBuffer).subarray(byteOffset);
-    const arrayCopy = new Uint8Array(subArray);
-    return arrayCopy.buffer;
-  }
-  var init_array_buffer_utils = __esm({
-    "../loader-utils/src/lib/binary-utils/array-buffer-utils.ts"() {
-    }
-  });
-
-  // ../loader-utils/src/lib/binary-utils/memory-copy-utils.ts
-  function padToNBytes(byteLength, padding) {
-    assert2(byteLength >= 0);
-    assert2(padding > 0);
-    return byteLength + (padding - 1) & ~(padding - 1);
-  }
-  function copyToArray(source, target, targetOffset) {
-    let sourceArray;
-    if (source instanceof ArrayBuffer) {
-      sourceArray = new Uint8Array(source);
-    } else {
-      const srcByteOffset = source.byteOffset;
-      const srcByteLength = source.byteLength;
-      sourceArray = new Uint8Array(source.buffer || source.arrayBuffer, srcByteOffset, srcByteLength);
-    }
-    target.set(sourceArray, targetOffset);
-    return targetOffset + padToNBytes(sourceArray.byteLength, 4);
-  }
-  var init_memory_copy_utils = __esm({
-    "../loader-utils/src/lib/binary-utils/memory-copy-utils.ts"() {
-      init_assert2();
-    }
-  });
-
-  // ../loader-utils/src/lib/binary-utils/binary-copy-utils.ts
-  function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
-    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 sourceArray = new Uint8Array(sourceBuffer);
-      targetArray.set(sourceArray);
-      for (let i2 = 0; i2 < padLength; ++i2) {
-        dataView.setUint8(byteOffset + sourceBuffer.byteLength + i2, 32);
-      }
-    }
-    byteOffset += paddedLength;
-    return byteOffset;
-  }
-  function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
-    const textEncoder = new TextEncoder();
-    const stringBuffer = textEncoder.encode(string);
-    byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);
-    return byteOffset;
-  }
-  var init_binary_copy_utils = __esm({
-    "../loader-utils/src/lib/binary-utils/binary-copy-utils.ts"() {
-      init_memory_copy_utils();
-    }
-  });
-
-  // ../loader-utils/src/index.ts
-  var init_src2 = __esm({
-    "../loader-utils/src/index.ts"() {
-      init_assert2();
-      init_globals2();
-      init_parse_json();
-      init_array_buffer_utils();
-      init_memory_copy_utils();
-      init_binary_copy_utils();
-    }
-  });
-
-  // ../images/src/lib/utils/version.ts
-  var VERSION6;
-  var init_version4 = __esm({
-    "../images/src/lib/utils/version.ts"() {
-      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-    }
-  });
-
-  // ../images/src/lib/category-api/image-type.ts
-  function isImageTypeSupported(type) {
-    switch (type) {
-      case "auto":
-        return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;
-      case "imagebitmap":
-        return IMAGE_BITMAP_SUPPORTED;
-      case "image":
-        return IMAGE_SUPPORTED;
-      case "data":
-        return DATA_SUPPORTED;
-      default:
-        throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
-    }
-  }
-  function getDefaultImageType() {
-    if (IMAGE_BITMAP_SUPPORTED) {
-      return "imagebitmap";
-    }
-    if (IMAGE_SUPPORTED) {
-      return "image";
-    }
-    if (DATA_SUPPORTED) {
-      return "data";
+    if (DATA_SUPPORTED) {
+      return "data";
     }
     throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js");
   }
@@ -824,7 +827,7 @@
       IMAGE_SUPPORTED = typeof Image !== "undefined";
       IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
       NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);
-      DATA_SUPPORTED = isBrowser2 ? true : NODE_IMAGE_SUPPORTED;
+      DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;
     }
   });
 
@@ -983,10 +986,62 @@
     }
   });
 
+  // ../images/src/lib/category-api/parse-isobmff-binary.ts
+  function getISOBMFFMediaType(buffer) {
+    if (!checkString(buffer, "ftyp", 4)) {
+      return null;
+    }
+    if ((buffer[8] & 96) === 0) {
+      return null;
+    }
+    return decodeMajorBrand(buffer);
+  }
+  function decodeMajorBrand(buffer) {
+    const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim();
+    switch (brandMajor) {
+      case "avif":
+      case "avis":
+        return { extension: "avif", mimeType: "image/avif" };
+      default:
+        return null;
+    }
+  }
+  function getUTF8String(array, start, end) {
+    return String.fromCharCode(...array.slice(start, end));
+  }
+  function stringToBytes(string) {
+    return [...string].map((character) => character.charCodeAt(0));
+  }
+  function checkString(buffer, header, offset = 0) {
+    const headerBytes = stringToBytes(header);
+    for (let i2 = 0; i2 < headerBytes.length; ++i2) {
+      if (headerBytes[i2] !== buffer[i2 + offset]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  var init_parse_isobmff_binary = __esm({
+    "../images/src/lib/category-api/parse-isobmff-binary.ts"() {
+    }
+  });
+
   // ../images/src/lib/category-api/binary-image-api.ts
   function getBinaryImageMetadata(binaryData) {
     const dataView = toDataView(binaryData);
-    return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView);
+    return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView);
+  }
+  function getISOBMFFMetadata(binaryData) {
+    const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData);
+    const mediaType = getISOBMFFMediaType(buffer);
+    if (!mediaType) {
+      return null;
+    }
+    return {
+      mimeType: mediaType.mimeType,
+      width: 0,
+      height: 0
+    };
   }
   function getPngMetadata(binaryData) {
     const dataView = toDataView(binaryData);
@@ -1087,6 +1142,7 @@
   var BIG_ENDIAN, LITTLE_ENDIAN;
   var init_binary_image_api = __esm({
     "../images/src/lib/category-api/binary-image-api.ts"() {
+      init_parse_isobmff_binary();
       BIG_ENDIAN = false;
       LITTLE_ENDIAN = true;
     }
@@ -1096,7 +1152,7 @@
   async function parseToNodeImage(arrayBuffer, options) {
     const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
     const _parseImageNode2 = globalThis._parseImageNode;
-    assert2(_parseImageNode2);
+    assert(_parseImageNode2);
     return await _parseImageNode2(arrayBuffer, mimeType);
   }
   var init_parse_to_node_image = __esm({
@@ -1125,7 +1181,7 @@
         image = await parseToNodeImage(arrayBuffer, options);
         break;
       default:
-        assert2(false);
+        assert(false);
     }
     if (imageType === "data") {
       image = getImageData(image);
@@ -1160,12 +1216,13 @@
       init_version4();
       init_parse_image();
       init_binary_image_api();
-      EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg"];
+      EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
       MIME_TYPES = [
         "image/png",
         "image/jpeg",
         "image/gif",
         "image/webp",
+        "image/avif",
         "image/bmp",
         "image/vnd.microsoft.icon",
         "image/svg+xml"
@@ -1191,43 +1248,41 @@
   });
 
   // ../images/src/lib/category-api/image-format.ts
-  function _isImageFormatSupported(mimeType) {
-    if (mimeTypeSupported[mimeType] === void 0) {
-      mimeTypeSupported[mimeType] = checkFormatSupport(mimeType);
+  function isImageFormatSupported(mimeType) {
+    if (mimeTypeSupportedSync[mimeType] === void 0) {
+      const supported = isBrowser ? checkBrowserImageFormatSupport(mimeType) : checkNodeImageFormatSupport(mimeType);
+      mimeTypeSupportedSync[mimeType] = supported;
     }
-    return mimeTypeSupported[mimeType];
+    return mimeTypeSupportedSync[mimeType];
   }
-  function checkFormatSupport(mimeType) {
+  function checkNodeImageFormatSupport(mimeType) {
+    const NODE_FORMAT_SUPPORT = ["image/png", "image/jpeg", "image/gif"];
+    const { _parseImageNode: _parseImageNode2, _imageFormatsNode = NODE_FORMAT_SUPPORT } = globalThis;
+    return Boolean(_parseImageNode2) && _imageFormatsNode.includes(mimeType);
+  }
+  function checkBrowserImageFormatSupport(mimeType) {
     switch (mimeType) {
+      case "image/avif":
       case "image/webp":
-        return checkWebPSupport();
-      case "image/svg":
-        return isBrowser2;
+        return testBrowserImageFormatSupport(mimeType);
       default:
-        if (!isBrowser2) {
-          const { _parseImageNode: _parseImageNode2 } = globalThis;
-          return Boolean(_parseImageNode2) && NODE_FORMAT_SUPPORT.includes(mimeType);
-        }
         return true;
     }
   }
-  function checkWebPSupport() {
-    if (!isBrowser2) {
-      return false;
-    }
+  function testBrowserImageFormatSupport(mimeType) {
     try {
       const element = document.createElement("canvas");
-      return element.toDataURL("image/webp").indexOf("data:image/webp") === 0;
+      const dataURL = element.toDataURL(mimeType);
+      return dataURL.indexOf(`data:${mimeType}`) === 0;
     } catch {
       return false;
     }
   }
-  var NODE_FORMAT_SUPPORT, mimeTypeSupported;
+  var mimeTypeSupportedSync;
   var init_image_format = __esm({
     "../images/src/lib/category-api/image-format.ts"() {
       init_src2();
-      NODE_FORMAT_SUPPORT = ["image/png", "image/jpeg", "image/gif"];
-      mimeTypeSupported = {};
+      mimeTypeSupportedSync = {};
     }
   });
 
@@ -1396,12 +1451,12 @@
           return extras[key];
         }
         getExtension(extensionName) {
-          const isExtension = this.getUsedExtensions().find((name8) => name8 === extensionName);
+          const isExtension = this.getUsedExtensions().find((name10) => name10 === extensionName);
           const extensions = this.json.extensions || {};
           return isExtension ? extensions[extensionName] || true : null;
         }
         getRequiredExtension(extensionName) {
-          const isRequired = this.getRequiredExtensions().find((name8) => name8 === extensionName);
+          const isRequired = this.getRequiredExtensions().find((name10) => name10 === extensionName);
           return isRequired ? this.getExtension(extensionName) : null;
         }
         getRequiredExtensions() {
@@ -1410,6 +1465,9 @@
         getUsedExtensions() {
           return this.json.extensionsUsed || [];
         }
+        getRemovedExtensions() {
+          return this.json.extensionsRemoved || [];
+        }
         getObjectExtension(object, extensionName) {
           const extensions = object.extensions || {};
           return extensions[extensionName];
@@ -1534,6 +1592,9 @@
           }
         }
         removeExtension(extensionName) {
+          if (!this.getExtension(extensionName)) {
+            return;
+          }
           if (this.json.extensionsRequired) {
             this._removeStringFromArray(this.json.extensionsRequired, extensionName);
           }
@@ -1543,6 +1604,13 @@
           if (this.json.extensions) {
             delete this.json.extensions[extensionName];
           }
+          if (!Array.isArray(this.json.extensionsRemoved)) {
+            this.json.extensionsRemoved = [];
+          }
+          const extensionsRemoved = this.json.extensionsRemoved;
+          if (!extensionsRemoved.includes(extensionName)) {
+            extensionsRemoved.push(extensionName);
+          }
         }
         setDefaultScene(sceneIndex) {
           this.json.scene = sceneIndex;
@@ -1753,9 +1821,6 @@
   });
 
   // src/meshopt/meshopt-decoder.ts
-  function isMeshoptSupported() {
-    return isWebAssemblySupported;
-  }
   async function meshoptDecodeGltfBuffer(target, count, size, source, mode, filter = "NONE") {
     const instance = await loadWasmInstance();
     decode(instance, instance.exports[DECODERS[mode]], target, count, size, source, instance.exports[FILTERS[filter || "NONE"]]);
@@ -1805,10 +1870,9 @@
       throw new Error(`Malformed buffer data: ${res}`);
     }
   }
-  var isWebAssemblySupported, wasm_base, wasm_simd, detector, wasmpack, FILTERS, DECODERS, wasmPromise;
+  var wasm_base, wasm_simd, detector, wasmpack, FILTERS, DECODERS, wasmPromise;
   var init_meshopt_decoder = __esm({
     "src/meshopt/meshopt-decoder.ts"() {
-      isWebAssemblySupported = typeof WebAssembly !== "object";
       wasm_base = "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";
       wasm_simd = "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";
       detector = new Uint8Array([
@@ -1951,15 +2015,8 @@
   var EXT_meshopt_compression_exports = {};
   __export(EXT_meshopt_compression_exports, {
     decode: () => decode2,
-    name: () => name,
-    preprocess: () => preprocess
+    name: () => name
   });
-  function preprocess(gltfData) {
-    const scenegraph = new GLTFScenegraph(gltfData);
-    if (scenegraph.getRequiredExtensions().includes(EXT_MESHOPT_COMPRESSION) && !isMeshoptSupported()) {
-      throw new Error(`gltf: Required extension ${EXT_MESHOPT_COMPRESSION} not supported by browser`);
-    }
-  }
   async function decode2(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
     if (!options?.gltf?.decompressMeshes) {
@@ -1975,18 +2032,19 @@
   async function decodeMeshoptBufferView(scenegraph, bufferView) {
     const meshoptExtension = scenegraph.getObjectExtension(bufferView, EXT_MESHOPT_COMPRESSION);
     if (meshoptExtension) {
-      const buffer = bufferView.buffer;
       const {
         byteOffset = 0,
         byteLength = 0,
         byteStride,
         count,
         mode,
-        filter = "NONE"
+        filter = "NONE",
+        buffer: bufferIndex
       } = meshoptExtension;
-      const source = new Uint8Array(buffer, byteOffset, byteLength);
-      const result = new ArrayBuffer(count * byteStride);
-      await meshoptDecodeGltfBuffer(new Uint8Array(result), count, byteStride, source, mode, filter);
+      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);
+      await meshoptDecodeGltfBuffer(result, count, byteStride, source, mode, filter);
       return result;
     }
     return null;
@@ -2005,11 +2063,11 @@
   var EXT_texture_webp_exports = {};
   __export(EXT_texture_webp_exports, {
     name: () => name2,
-    preprocess: () => preprocess2
+    preprocess: () => preprocess
   });
-  function preprocess2(gltfData, options) {
+  function preprocess(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
-    if (!_isImageFormatSupported("image/webp")) {
+    if (!isImageFormatSupported("image/webp")) {
       if (scenegraph.getRequiredExtensions().includes(EXT_TEXTURE_WEBP)) {
         throw new Error(`gltf: Required extension ${EXT_TEXTURE_WEBP} not supported by browser`);
       }
@@ -2039,9 +2097,9 @@
   var KHR_texture_basisu_exports = {};
   __export(KHR_texture_basisu_exports, {
     name: () => name3,
-    preprocess: () => preprocess3
+    preprocess: () => preprocess2
   });
-  function preprocess3(gltfData, options) {
+  function preprocess2(gltfData, options) {
     const scene = new GLTFScenegraph(gltfData);
     const { json } = scene;
     for (const texture of json.textures || []) {
@@ -2074,6 +2132,7 @@
   var DEFAULT_DRACO_OPTIONS, DracoLoader;
   var init_draco_loader = __esm({
     "../draco/src/draco-loader.ts"() {
+      init_src();
       init_version5();
       DEFAULT_DRACO_OPTIONS = {
         draco: {
@@ -2085,9 +2144,8 @@
       };
       DracoLoader = {
         name: "Draco",
-        id: "draco",
+        id: isBrowser2 ? "draco" : "draco-nodejs",
         module: "draco",
-        shapes: ["mesh"],
         version: VERSION7,
         worker: true,
         extensions: ["drc"],
@@ -2099,7 +2157,36 @@
     }
   });
 
-  // ../schema/src/category/mesh/mesh-utils.ts
+  // ../schema/src/lib/table/simple-table/data-type.ts
+  function getDataTypeFromTypedArray(array) {
+    switch (array.constructor) {
+      case Int8Array:
+        return "int8";
+      case Uint8Array:
+      case Uint8ClampedArray:
+        return "uint8";
+      case Int16Array:
+        return "int16";
+      case Uint16Array:
+        return "uint16";
+      case Int32Array:
+        return "int32";
+      case Uint32Array:
+        return "uint32";
+      case Float32Array:
+        return "float32";
+      case Float64Array:
+        return "float64";
+      default:
+        return "null";
+    }
+  }
+  var init_data_type = __esm({
+    "../schema/src/lib/table/simple-table/data-type.ts"() {
+    }
+  });
+
+  // ../schema/src/lib/mesh/mesh-utils.ts
   function getMeshBoundingBox(attributes) {
     let minX = Infinity;
     let minY = Infinity;
@@ -2126,595 +2213,88 @@
     ];
   }
   var init_mesh_utils = __esm({
-    "../schema/src/category/mesh/mesh-utils.ts"() {
+    "../schema/src/lib/mesh/mesh-utils.ts"() {
     }
   });
 
-  // ../schema/src/lib/utils/assert.ts
-  function assert4(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loader assertion failed.");
-    }
+  // ../schema/src/lib/mesh/deduce-mesh-schema.ts
+  function deduceMeshField(name10, attribute, optionalMetadata) {
+    const type = getDataTypeFromTypedArray(attribute.value);
+    const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
+    return {
+      name: name10,
+      type: { type: "fixed-size-list", listSize: attribute.size, children: [{ name: "value", type }] },
+      nullable: false,
+      metadata
+    };
   }
-  var init_assert4 = __esm({
-    "../schema/src/lib/utils/assert.ts"() {
+  function makeMeshAttributeMetadata(attribute) {
+    const result = {};
+    if ("byteOffset" in attribute) {
+      result.byteOffset = attribute.byteOffset.toString(10);
     }
-  });
-
-  // ../schema/src/lib/schema/impl/schema.ts
-  function checkNames(fields) {
-    const usedNames = {};
-    for (const field of fields) {
-      if (usedNames[field.name]) {
-        console.warn("Schema: duplicated field name", field.name, field);
-      }
-      usedNames[field.name] = true;
+    if ("byteStride" in attribute) {
+      result.byteStride = attribute.byteStride.toString(10);
     }
+    if ("normalized" in attribute) {
+      result.normalized = attribute.normalized.toString();
+    }
+    return result;
   }
-  function mergeMaps(m1, m2) {
-    return new Map([...m1 || new Map(), ...m2 || new Map()]);
-  }
-  var Schema;
-  var init_schema = __esm({
-    "../schema/src/lib/schema/impl/schema.ts"() {
-      init_assert4();
-      Schema = class {
-        constructor(fields, metadata) {
-          assert4(Array.isArray(fields));
-          checkNames(fields);
-          this.fields = fields;
-          this.metadata = metadata || new Map();
-        }
-        compareTo(other) {
-          if (this.metadata !== other.metadata) {
-            return false;
-          }
-          if (this.fields.length !== other.fields.length) {
-            return false;
-          }
-          for (let i2 = 0; i2 < this.fields.length; ++i2) {
-            if (!this.fields[i2].compareTo(other.fields[i2])) {
-              return false;
-            }
-          }
-          return true;
-        }
-        select(...columnNames) {
-          const nameMap = Object.create(null);
-          for (const name8 of columnNames) {
-            nameMap[name8] = true;
-          }
-          const selectedFields = this.fields.filter((field) => nameMap[field.name]);
-          return new Schema(selectedFields, this.metadata);
-        }
-        selectAt(...columnIndices) {
-          const selectedFields = columnIndices.map((index) => this.fields[index]).filter(Boolean);
-          return new Schema(selectedFields, this.metadata);
-        }
-        assign(schemaOrFields) {
-          let fields;
-          let metadata = this.metadata;
-          if (schemaOrFields instanceof Schema) {
-            const otherSchema = schemaOrFields;
-            fields = otherSchema.fields;
-            metadata = mergeMaps(mergeMaps(new Map(), this.metadata), otherSchema.metadata);
-          } else {
-            fields = schemaOrFields;
-          }
-          const fieldMap = Object.create(null);
-          for (const field of this.fields) {
-            fieldMap[field.name] = field;
-          }
-          for (const field of fields) {
-            fieldMap[field.name] = field;
-          }
-          const mergedFields = Object.values(fieldMap);
-          return new Schema(mergedFields, metadata);
-        }
-      };
+  var init_deduce_mesh_schema = __esm({
+    "../schema/src/lib/mesh/deduce-mesh-schema.ts"() {
+      init_data_type();
     }
   });
 
-  // ../schema/src/lib/schema/impl/field.ts
-  var Field;
-  var init_field = __esm({
-    "../schema/src/lib/schema/impl/field.ts"() {
-      Field = class {
-        constructor(name8, type, nullable = false, metadata = new Map()) {
-          this.name = name8;
-          this.type = type;
-          this.nullable = nullable;
-          this.metadata = metadata;
-        }
-        get typeId() {
-          return this.type && this.type.typeId;
-        }
-        clone() {
-          return new Field(this.name, this.type, this.nullable, this.metadata);
-        }
-        compareTo(other) {
-          return this.name === other.name && this.type === other.type && this.nullable === other.nullable && this.metadata === other.metadata;
-        }
-        toString() {
-          return `${this.type}${this.nullable ? ", nullable" : ""}${this.metadata ? `, metadata: ${this.metadata}` : ""}`;
-        }
-      };
+  // ../schema/src/index.ts
+  var init_src5 = __esm({
+    "../schema/src/index.ts"() {
+      init_mesh_utils();
+      init_deduce_mesh_schema();
     }
   });
 
-  // ../schema/src/lib/schema/impl/enum.ts
-  var Type;
-  var init_enum = __esm({
-    "../schema/src/lib/schema/impl/enum.ts"() {
-      (function(Type2) {
-        Type2[Type2["NONE"] = 0] = "NONE";
-        Type2[Type2["Null"] = 1] = "Null";
-        Type2[Type2["Int"] = 2] = "Int";
-        Type2[Type2["Float"] = 3] = "Float";
-        Type2[Type2["Binary"] = 4] = "Binary";
-        Type2[Type2["Utf8"] = 5] = "Utf8";
-        Type2[Type2["Bool"] = 6] = "Bool";
-        Type2[Type2["Decimal"] = 7] = "Decimal";
-        Type2[Type2["Date"] = 8] = "Date";
-        Type2[Type2["Time"] = 9] = "Time";
-        Type2[Type2["Timestamp"] = 10] = "Timestamp";
-        Type2[Type2["Interval"] = 11] = "Interval";
-        Type2[Type2["List"] = 12] = "List";
-        Type2[Type2["Struct"] = 13] = "Struct";
-        Type2[Type2["Union"] = 14] = "Union";
-        Type2[Type2["FixedSizeBinary"] = 15] = "FixedSizeBinary";
-        Type2[Type2["FixedSizeList"] = 16] = "FixedSizeList";
-        Type2[Type2["Map"] = 17] = "Map";
-        Type2[Type2["Dictionary"] = -1] = "Dictionary";
-        Type2[Type2["Int8"] = -2] = "Int8";
-        Type2[Type2["Int16"] = -3] = "Int16";
-        Type2[Type2["Int32"] = -4] = "Int32";
-        Type2[Type2["Int64"] = -5] = "Int64";
-        Type2[Type2["Uint8"] = -6] = "Uint8";
-        Type2[Type2["Uint16"] = -7] = "Uint16";
-        Type2[Type2["Uint32"] = -8] = "Uint32";
-        Type2[Type2["Uint64"] = -9] = "Uint64";
-        Type2[Type2["Float16"] = -10] = "Float16";
-        Type2[Type2["Float32"] = -11] = "Float32";
-        Type2[Type2["Float64"] = -12] = "Float64";
-        Type2[Type2["DateDay"] = -13] = "DateDay";
-        Type2[Type2["DateMillisecond"] = -14] = "DateMillisecond";
-        Type2[Type2["TimestampSecond"] = -15] = "TimestampSecond";
-        Type2[Type2["TimestampMillisecond"] = -16] = "TimestampMillisecond";
-        Type2[Type2["TimestampMicrosecond"] = -17] = "TimestampMicrosecond";
-        Type2[Type2["TimestampNanosecond"] = -18] = "TimestampNanosecond";
-        Type2[Type2["TimeSecond"] = -19] = "TimeSecond";
-        Type2[Type2["TimeMillisecond"] = -20] = "TimeMillisecond";
-        Type2[Type2["TimeMicrosecond"] = -21] = "TimeMicrosecond";
-        Type2[Type2["TimeNanosecond"] = -22] = "TimeNanosecond";
-        Type2[Type2["DenseUnion"] = -23] = "DenseUnion";
-        Type2[Type2["SparseUnion"] = -24] = "SparseUnion";
-        Type2[Type2["IntervalDayTime"] = -25] = "IntervalDayTime";
-        Type2[Type2["IntervalYearMonth"] = -26] = "IntervalYearMonth";
-      })(Type || (Type = {}));
-    }
-  });
-
-  // ../schema/src/lib/schema/impl/type.ts
-  var DataType, Null, Bool, Int, Int8, Int16, Int32, Uint8, Uint16, Uint32, Precision, Float, Float32, Float64, Binary, Utf8, DateUnit, Date, TimeUnit, Time, Timestamp, IntervalUnit, Interval, FixedSizeList, Struct;
-  var init_type = __esm({
-    "../schema/src/lib/schema/impl/type.ts"() {
-      init_enum();
-      DataType = class {
-        static isNull(x) {
-          return x && x.typeId === Type.Null;
-        }
-        static isInt(x) {
-          return x && x.typeId === Type.Int;
-        }
-        static isFloat(x) {
-          return x && x.typeId === Type.Float;
-        }
-        static isBinary(x) {
-          return x && x.typeId === Type.Binary;
-        }
-        static isUtf8(x) {
-          return x && x.typeId === Type.Utf8;
-        }
-        static isBool(x) {
-          return x && x.typeId === Type.Bool;
-        }
-        static isDecimal(x) {
-          return x && x.typeId === Type.Decimal;
-        }
-        static isDate(x) {
-          return x && x.typeId === Type.Date;
-        }
-        static isTime(x) {
-          return x && x.typeId === Type.Time;
-        }
-        static isTimestamp(x) {
-          return x && x.typeId === Type.Timestamp;
-        }
-        static isInterval(x) {
-          return x && x.typeId === Type.Interval;
-        }
-        static isList(x) {
-          return x && x.typeId === Type.List;
-        }
-        static isStruct(x) {
-          return x && x.typeId === Type.Struct;
-        }
-        static isUnion(x) {
-          return x && x.typeId === Type.Union;
-        }
-        static isFixedSizeBinary(x) {
-          return x && x.typeId === Type.FixedSizeBinary;
-        }
-        static isFixedSizeList(x) {
-          return x && x.typeId === Type.FixedSizeList;
-        }
-        static isMap(x) {
-          return x && x.typeId === Type.Map;
-        }
-        static isDictionary(x) {
-          return x && x.typeId === Type.Dictionary;
-        }
-        get typeId() {
-          return Type.NONE;
-        }
-        compareTo(other) {
-          return this === other;
-        }
-      };
-      Null = class extends DataType {
-        get typeId() {
-          return Type.Null;
-        }
-        get [Symbol.toStringTag]() {
-          return "Null";
-        }
-        toString() {
-          return "Null";
-        }
-      };
-      Bool = class extends DataType {
-        get typeId() {
-          return Type.Bool;
-        }
-        get [Symbol.toStringTag]() {
-          return "Bool";
-        }
-        toString() {
-          return "Bool";
-        }
-      };
-      Int = class extends DataType {
-        constructor(isSigned, bitWidth) {
-          super();
-          this.isSigned = isSigned;
-          this.bitWidth = bitWidth;
-        }
-        get typeId() {
-          return Type.Int;
-        }
-        get [Symbol.toStringTag]() {
-          return "Int";
-        }
-        toString() {
-          return `${this.isSigned ? "I" : "Ui"}nt${this.bitWidth}`;
-        }
-      };
-      Int8 = class extends Int {
-        constructor() {
-          super(true, 8);
-        }
-      };
-      Int16 = class extends Int {
-        constructor() {
-          super(true, 16);
-        }
-      };
-      Int32 = class extends Int {
-        constructor() {
-          super(true, 32);
-        }
-      };
-      Uint8 = class extends Int {
-        constructor() {
-          super(false, 8);
-        }
-      };
-      Uint16 = class extends Int {
-        constructor() {
-          super(false, 16);
-        }
-      };
-      Uint32 = class extends Int {
-        constructor() {
-          super(false, 32);
-        }
-      };
-      Precision = {
-        HALF: 16,
-        SINGLE: 32,
-        DOUBLE: 64
-      };
-      Float = class extends DataType {
-        constructor(precision) {
-          super();
-          this.precision = precision;
-        }
-        get typeId() {
-          return Type.Float;
-        }
-        get [Symbol.toStringTag]() {
-          return "Float";
-        }
-        toString() {
-          return `Float${this.precision}`;
-        }
-      };
-      Float32 = class extends Float {
-        constructor() {
-          super(Precision.SINGLE);
-        }
-      };
-      Float64 = class extends Float {
-        constructor() {
-          super(Precision.DOUBLE);
-        }
-      };
-      Binary = class extends DataType {
-        constructor() {
-          super();
-        }
-        get typeId() {
-          return Type.Binary;
-        }
-        toString() {
-          return "Binary";
-        }
-        get [Symbol.toStringTag]() {
-          return "Binary";
-        }
-      };
-      Utf8 = class extends DataType {
-        get typeId() {
-          return Type.Utf8;
-        }
-        get [Symbol.toStringTag]() {
-          return "Utf8";
-        }
-        toString() {
-          return "Utf8";
-        }
-      };
-      DateUnit = {
-        DAY: 0,
-        MILLISECOND: 1
-      };
-      Date = class extends DataType {
-        constructor(unit) {
-          super();
-          this.unit = unit;
-        }
-        get typeId() {
-          return Type.Date;
-        }
-        get [Symbol.toStringTag]() {
-          return "Date";
-        }
-        toString() {
-          return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`;
-        }
-      };
-      TimeUnit = {
-        SECOND: 1,
-        MILLISECOND: 1e3,
-        MICROSECOND: 1e6,
-        NANOSECOND: 1e9
-      };
-      Time = class extends DataType {
-        constructor(unit, bitWidth) {
-          super();
-          this.unit = unit;
-          this.bitWidth = bitWidth;
-        }
-        get typeId() {
-          return Type.Time;
-        }
-        toString() {
-          return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`;
-        }
-        get [Symbol.toStringTag]() {
-          return "Time";
-        }
-      };
-      Timestamp = class extends DataType {
-        constructor(unit, timezone = null) {
-          super();
-          this.unit = unit;
-          this.timezone = timezone;
-        }
-        get typeId() {
-          return Type.Timestamp;
-        }
-        get [Symbol.toStringTag]() {
-          return "Timestamp";
-        }
-        toString() {
-          return `Timestamp<${TimeUnit[this.unit]}${this.timezone ? `, ${this.timezone}` : ""}>`;
-        }
-      };
-      IntervalUnit = {
-        DAY_TIME: 0,
-        YEAR_MONTH: 1
-      };
-      Interval = class extends DataType {
-        constructor(unit) {
-          super();
-          this.unit = unit;
-        }
-        get typeId() {
-          return Type.Interval;
-        }
-        get [Symbol.toStringTag]() {
-          return "Interval";
-        }
-        toString() {
-          return `Interval<${IntervalUnit[this.unit]}>`;
-        }
-      };
-      FixedSizeList = class extends DataType {
-        constructor(listSize, child) {
-          super();
-          this.listSize = listSize;
-          this.children = [child];
-        }
-        get typeId() {
-          return Type.FixedSizeList;
-        }
-        get valueType() {
-          return this.children[0].type;
-        }
-        get valueField() {
-          return this.children[0];
-        }
-        get [Symbol.toStringTag]() {
-          return "FixedSizeList";
-        }
-        toString() {
-          return `FixedSizeList[${this.listSize}]<${this.valueType}>`;
-        }
-      };
-      Struct = class extends DataType {
-        constructor(children) {
-          super();
-          this.children = children;
-        }
-        get typeId() {
-          return Type.Struct;
-        }
-        toString() {
-          return `Struct<{${this.children.map((f2) => `${f2.name}:${f2.type}`).join(", ")}}>`;
-        }
-        get [Symbol.toStringTag]() {
-          return "Struct";
-        }
-      };
-    }
-  });
-
-  // ../schema/src/lib/schema/schema.ts
-  var init_schema2 = __esm({
-    "../schema/src/lib/schema/schema.ts"() {
-      init_schema();
-      init_field();
-      init_type();
-    }
-  });
-
-  // ../schema/src/lib/arrow/arrow-like-type-utils.ts
-  function getArrowTypeFromTypedArray(array) {
-    switch (array.constructor) {
-      case Int8Array:
-        return new Int8();
-      case Uint8Array:
-        return new Uint8();
-      case Int16Array:
-        return new Int16();
-      case Uint16Array:
-        return new Uint16();
-      case Int32Array:
-        return new Int32();
-      case Uint32Array:
-        return new Uint32();
-      case Float32Array:
-        return new Float32();
-      case Float64Array:
-        return new Float64();
-      default:
-        throw new Error("array type not supported");
-    }
-  }
-  var init_arrow_like_type_utils = __esm({
-    "../schema/src/lib/arrow/arrow-like-type-utils.ts"() {
-      init_schema2();
-    }
-  });
-
-  // ../schema/src/category/mesh/deduce-mesh-schema.ts
-  function deduceMeshField(attributeName, attribute, optionalMetadata) {
-    const type = getArrowTypeFromTypedArray(attribute.value);
-    const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
-    const field = new Field(attributeName, new FixedSizeList(attribute.size, new Field("value", type)), false, metadata);
-    return field;
-  }
-  function makeMeshAttributeMetadata(attribute) {
-    const result = new Map();
-    if ("byteOffset" in attribute) {
-      result.set("byteOffset", attribute.byteOffset.toString(10));
-    }
-    if ("byteStride" in attribute) {
-      result.set("byteStride", attribute.byteStride.toString(10));
-    }
-    if ("normalized" in attribute) {
-      result.set("normalized", attribute.normalized.toString());
-    }
-    return result;
-  }
-  var init_deduce_mesh_schema = __esm({
-    "../schema/src/category/mesh/deduce-mesh-schema.ts"() {
-      init_schema2();
-      init_arrow_like_type_utils();
-    }
-  });
-
-  // ../schema/src/index.ts
-  var init_src5 = __esm({
-    "../schema/src/index.ts"() {
-      init_mesh_utils();
-      init_deduce_mesh_schema();
-      init_schema2();
-    }
-  });
-
-  // ../draco/src/lib/utils/get-draco-schema.ts
-  function getDracoSchema(attributes, loaderData, indices) {
-    const metadataMap = makeMetadata(loaderData.metadata);
-    const fields = [];
-    const namedLoaderDataAttributes = transformAttributesLoaderData(loaderData.attributes);
-    for (const attributeName in attributes) {
-      const attribute = attributes[attributeName];
-      const field = getArrowFieldFromAttribute(attributeName, attribute, namedLoaderDataAttributes[attributeName]);
-      fields.push(field);
-    }
-    if (indices) {
-      const indicesField = getArrowFieldFromAttribute("indices", indices);
-      fields.push(indicesField);
-    }
-    return new Schema(fields, metadataMap);
-  }
-  function transformAttributesLoaderData(loaderData) {
-    const result = {};
-    for (const key in loaderData) {
-      const dracoAttribute = loaderData[key];
-      result[dracoAttribute.name || "undefined"] = dracoAttribute;
-    }
-    return result;
-  }
-  function getArrowFieldFromAttribute(attributeName, attribute, loaderData) {
-    const metadataMap = loaderData ? makeMetadata(loaderData.metadata) : void 0;
-    const field = deduceMeshField(attributeName, attribute, metadataMap);
-    return field;
-  }
-  function makeMetadata(metadata) {
-    const metadataMap = new Map();
-    for (const key in metadata) {
-      metadataMap.set(`${key}.string`, JSON.stringify(metadata[key]));
-    }
-    return metadataMap;
-  }
-  var init_get_draco_schema = __esm({
-    "../draco/src/lib/utils/get-draco-schema.ts"() {
-      init_src5();
-      init_src5();
+  // ../draco/src/lib/utils/get-draco-schema.ts
+  function getDracoSchema(attributes, loaderData, indices) {
+    const metadata = makeMetadata(loaderData.metadata);
+    const fields = [];
+    const namedLoaderDataAttributes = transformAttributesLoaderData(loaderData.attributes);
+    for (const attributeName in attributes) {
+      const attribute = attributes[attributeName];
+      const field = getArrowFieldFromAttribute(attributeName, attribute, namedLoaderDataAttributes[attributeName]);
+      fields.push(field);
+    }
+    if (indices) {
+      const indicesField = getArrowFieldFromAttribute("indices", indices);
+      fields.push(indicesField);
+    }
+    return { fields, metadata };
+  }
+  function transformAttributesLoaderData(loaderData) {
+    const result = {};
+    for (const key in loaderData) {
+      const dracoAttribute = loaderData[key];
+      result[dracoAttribute.name || "undefined"] = dracoAttribute;
+    }
+    return result;
+  }
+  function getArrowFieldFromAttribute(attributeName, attribute, loaderData) {
+    const metadataMap = loaderData ? makeMetadata(loaderData.metadata) : void 0;
+    const field = deduceMeshField(attributeName, attribute, metadataMap);
+    return field;
+  }
+  function makeMetadata(metadata) {
+    Object.entries(metadata);
+    const serializedMetadata = {};
+    for (const key in metadata) {
+      serializedMetadata[`${key}.string`] = JSON.stringify(metadata[key]);
+    }
+    return serializedMetadata;
+  }
+  var init_get_draco_schema = __esm({
+    "../draco/src/lib/utils/get-draco-schema.ts"() {
+      init_src5();
     }
   });
 
@@ -3106,15 +2686,17 @@
       });
     });
   }
-  var DRACO_VERSION, DRACO_JS_DECODER_URL, DRACO_WASM_WRAPPER_URL, DRACO_WASM_DECODER_URL, DRACO_ENCODER_URL, loadDecoderPromise;
+  var DRACO_DECODER_VERSION, DRACO_ENCODER_VERSION, STATIC_DECODER_URL, DRACO_JS_DECODER_URL, DRACO_WASM_WRAPPER_URL, DRACO_WASM_DECODER_URL, DRACO_ENCODER_URL, loadDecoderPromise;
   var init_draco_module_loader = __esm({
     "../draco/src/lib/draco-module-loader.ts"() {
       init_src();
-      DRACO_VERSION = "1.4.1";
-      DRACO_JS_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_decoder.js`;
-      DRACO_WASM_WRAPPER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_wasm_wrapper.js`;
-      DRACO_WASM_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_decoder.wasm`;
-      DRACO_ENCODER_URL = `https://raw.githubusercontent.com/google/draco/${DRACO_VERSION}/javascript/draco_encoder.js`;
+      DRACO_DECODER_VERSION = "1.5.5";
+      DRACO_ENCODER_VERSION = "1.4.1";
+      STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
+      DRACO_JS_DECODER_URL = `${STATIC_DECODER_URL}/draco_decoder.js`;
+      DRACO_WASM_WRAPPER_URL = `${STATIC_DECODER_URL}/draco_wasm_wrapper.js`;
+      DRACO_WASM_DECODER_URL = `${STATIC_DECODER_URL}/draco_decoder.wasm`;
+      DRACO_ENCODER_URL = `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_VERSION}/javascript/draco_encoder.js`;
     }
   });
 
@@ -3141,184 +2723,1528 @@
     }
   });
 
-  // src/lib/gltf-utils/gltf-attribute-utils.ts
-  function getGLTFAccessors(attributes) {
-    const accessors = {};
-    for (const name8 in attributes) {
-      const attribute = attributes[name8];
-      if (name8 !== "indices") {
-        const glTFAccessor = getGLTFAccessor(attribute);
-        accessors[name8] = glTFAccessor;
-      }
-    }
-    return accessors;
-  }
-  function getGLTFAccessor(attribute) {
-    const { buffer, size, count } = getAccessorData(attribute);
-    const glTFAccessor = {
-      value: buffer,
-      size,
-      byteOffset: 0,
-      count,
-      type: getAccessorTypeFromSize(size),
-      componentType: getComponentTypeFromArray(buffer)
-    };
-    return glTFAccessor;
-  }
-  function getAccessorData(attribute) {
-    let buffer = attribute;
-    let size = 1;
-    let count = 0;
-    if (attribute && attribute.value) {
-      buffer = attribute.value;
-      size = attribute.size || 1;
-    }
-    if (buffer) {
-      if (!ArrayBuffer.isView(buffer)) {
-        buffer = toTypedArray(buffer, Float32Array);
-      }
-      count = buffer.length / size;
-    }
-    return { buffer, size, count };
-  }
-  function toTypedArray(array, ArrayType, convertTypedArrays = false) {
-    if (!array) {
+  // src/lib/gltf-utils/gltf-attribute-utils.ts
+  function getGLTFAccessors(attributes) {
+    const accessors = {};
+    for (const name10 in attributes) {
+      const attribute = attributes[name10];
+      if (name10 !== "indices") {
+        const glTFAccessor = getGLTFAccessor(attribute);
+        accessors[name10] = glTFAccessor;
+      }
+    }
+    return accessors;
+  }
+  function getGLTFAccessor(attribute) {
+    const { buffer, size, count } = getAccessorData(attribute);
+    const glTFAccessor = {
+      value: buffer,
+      size,
+      byteOffset: 0,
+      count,
+      type: getAccessorTypeFromSize(size),
+      componentType: getComponentTypeFromArray(buffer)
+    };
+    return glTFAccessor;
+  }
+  function getAccessorData(attribute) {
+    let buffer = attribute;
+    let size = 1;
+    let count = 0;
+    if (attribute && attribute.value) {
+      buffer = attribute.value;
+      size = attribute.size || 1;
+    }
+    if (buffer) {
+      if (!ArrayBuffer.isView(buffer)) {
+        buffer = toTypedArray(buffer, Float32Array);
+      }
+      count = buffer.length / size;
+    }
+    return { buffer, size, count };
+  }
+  function toTypedArray(array, ArrayType, convertTypedArrays = false) {
+    if (!array) {
+      return null;
+    }
+    if (Array.isArray(array)) {
+      return new ArrayType(array);
+    }
+    if (convertTypedArrays && !(array instanceof ArrayType)) {
+      return new ArrayType(array);
+    }
+    return array;
+  }
+  var init_gltf_attribute_utils = __esm({
+    "src/lib/gltf-utils/gltf-attribute-utils.ts"() {
+      init_gltf_utils();
+    }
+  });
+
+  // src/lib/extensions/KHR_draco_mesh_compression.ts
+  var KHR_draco_mesh_compression_exports = {};
+  __export(KHR_draco_mesh_compression_exports, {
+    decode: () => decode3,
+    encode: () => encode,
+    name: () => name4,
+    preprocess: () => preprocess3
+  });
+  function preprocess3(gltfData, options, context) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    for (const primitive of makeMeshPrimitiveIterator(scenegraph)) {
+      if (scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION)) {
+      }
+    }
+  }
+  async function decode3(gltfData, options, context) {
+    if (!options?.gltf?.decompressMeshes) {
+      return;
+    }
+    const scenegraph = new GLTFScenegraph(gltfData);
+    const promises = [];
+    for (const primitive of makeMeshPrimitiveIterator(scenegraph)) {
+      if (scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION)) {
+        promises.push(decompressPrimitive(scenegraph, primitive, options, context));
+      }
+    }
+    await Promise.all(promises);
+    scenegraph.removeExtension(KHR_DRACO_MESH_COMPRESSION);
+  }
+  function encode(gltfData, options = {}) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    for (const mesh of scenegraph.json.meshes || []) {
+      compressMesh(mesh, options);
+      scenegraph.addRequiredExtension(KHR_DRACO_MESH_COMPRESSION);
+    }
+  }
+  async function decompressPrimitive(scenegraph, primitive, options, context) {
+    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 { parse: parse4 } = context;
+    const dracoOptions = { ...options };
+    delete dracoOptions["3d-tiles"];
+    const decodedData = await parse4(bufferCopy, DracoLoader2, dracoOptions, context);
+    const decodedAttributes = getGLTFAccessors(decodedData.attributes);
+    for (const [attributeName, decodedAttribute] of Object.entries(decodedAttributes)) {
+      if (attributeName in primitive.attributes) {
+        const accessorIndex = primitive.attributes[attributeName];
+        const accessor = scenegraph.getAccessor(accessorIndex);
+        if (accessor?.min && accessor?.max) {
+          decodedAttribute.min = accessor.min;
+          decodedAttribute.max = accessor.max;
+        }
+      }
+    }
+    primitive.attributes = decodedAttributes;
+    if (decodedData.indices) {
+      primitive.indices = getGLTFAccessor(decodedData.indices);
+    }
+    checkPrimitive(primitive);
+  }
+  function compressMesh(attributes, indices, mode = 4, options, context) {
+    if (!options.DracoWriter) {
+      throw new Error("options.gltf.DracoWriter not provided");
+    }
+    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
+            }
+          }
+        }
+      ]
+    };
+    return glTFMesh;
+  }
+  function checkPrimitive(primitive) {
+    if (!primitive.attributes && Object.keys(primitive.attributes).length > 0) {
+      throw new Error("glTF: Empty primitive detected: Draco decompression failure?");
+    }
+  }
+  function* makeMeshPrimitiveIterator(scenegraph) {
+    for (const mesh of scenegraph.json.meshes || []) {
+      for (const primitive of mesh.primitives) {
+        yield primitive;
+      }
+    }
+  }
+  var KHR_DRACO_MESH_COMPRESSION, name4;
+  var init_KHR_draco_mesh_compression = __esm({
+    "src/lib/extensions/KHR_draco_mesh_compression.ts"() {
+      init_src6();
+      init_src2();
+      init_gltf_scenegraph();
+      init_gltf_attribute_utils();
+      KHR_DRACO_MESH_COMPRESSION = "KHR_draco_mesh_compression";
+      name4 = KHR_DRACO_MESH_COMPRESSION;
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/lib/assert.js
+  function assert4(condition, message) {
+    if (!condition) {
+      throw new Error("math.gl assertion ".concat(message));
+    }
+  }
+  var init_assert4 = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/lib/assert.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/lib/common.js
+  function formatValue(value, {
+    precision = config.precision
+  } = {}) {
+    value = round(value);
+    return "".concat(parseFloat(value.toPrecision(precision)));
+  }
+  function isArray(value) {
+    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+  }
+  function equals(a2, b, epsilon) {
+    const oldEpsilon = config.EPSILON;
+    if (epsilon) {
+      config.EPSILON = epsilon;
+    }
+    try {
+      if (a2 === b) {
+        return true;
+      }
+      if (isArray(a2) && isArray(b)) {
+        if (a2.length !== b.length) {
+          return false;
+        }
+        for (let i2 = 0; i2 < a2.length; ++i2) {
+          if (!equals(a2[i2], b[i2])) {
+            return false;
+          }
+        }
+        return true;
+      }
+      if (a2 && a2.equals) {
+        return a2.equals(b);
+      }
+      if (b && b.equals) {
+        return b.equals(a2);
+      }
+      if (typeof a2 === "number" && typeof b === "number") {
+        return Math.abs(a2 - b) <= config.EPSILON * Math.max(1, Math.abs(a2), Math.abs(b));
+      }
+      return false;
+    } finally {
+      config.EPSILON = oldEpsilon;
+    }
+  }
+  function round(value) {
+    return Math.round(value / config.EPSILON) * config.EPSILON;
+  }
+  var RADIANS_TO_DEGREES, DEGREES_TO_RADIANS, config;
+  var init_common = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/lib/common.js"() {
+      RADIANS_TO_DEGREES = 1 / Math.PI * 180;
+      DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
+      config = {
+        EPSILON: 1e-12,
+        debug: false,
+        precision: 4,
+        printTypes: false,
+        printDegrees: false,
+        printRowMajor: true
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/classes/base/math-array.js
+  function _extendableBuiltin(cls) {
+    function ExtendableBuiltin() {
+      var instance = Reflect.construct(cls, Array.from(arguments));
+      Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+      return instance;
+    }
+    ExtendableBuiltin.prototype = Object.create(cls.prototype, {
+      constructor: {
+        value: cls,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(ExtendableBuiltin, cls);
+    } else {
+      ExtendableBuiltin.__proto__ = cls;
+    }
+    return ExtendableBuiltin;
+  }
+  var MathArray;
+  var init_math_array = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/classes/base/math-array.js"() {
+      init_common();
+      MathArray = class extends _extendableBuiltin(Array) {
+        clone() {
+          return new this.constructor().copy(this);
+        }
+        fromArray(array, offset = 0) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = array[i2 + offset];
+          }
+          return this.check();
+        }
+        toArray(targetArray = [], offset = 0) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            targetArray[offset + i2] = this[i2];
+          }
+          return targetArray;
+        }
+        from(arrayOrObject) {
+          return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+        }
+        to(arrayOrObject) {
+          if (arrayOrObject === this) {
+            return this;
+          }
+          return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
+        }
+        toTarget(target) {
+          return target ? this.to(target) : this;
+        }
+        toFloat32Array() {
+          return new Float32Array(this);
+        }
+        toString() {
+          return this.formatString(config);
+        }
+        formatString(opts) {
+          let string = "";
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            string += (i2 > 0 ? ", " : "") + formatValue(this[i2], opts);
+          }
+          return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]");
+        }
+        equals(array) {
+          if (!array || this.length !== array.length) {
+            return false;
+          }
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            if (!equals(this[i2], array[i2])) {
+              return false;
+            }
+          }
+          return true;
+        }
+        exactEquals(array) {
+          if (!array || this.length !== array.length) {
+            return false;
+          }
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            if (this[i2] !== array[i2]) {
+              return false;
+            }
+          }
+          return true;
+        }
+        negate() {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = -this[i2];
+          }
+          return this.check();
+        }
+        lerp(a2, b, t2) {
+          if (t2 === void 0) {
+            return this.lerp(this, a2, b);
+          }
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            const ai = a2[i2];
+            this[i2] = ai + t2 * (b[i2] - ai);
+          }
+          return this.check();
+        }
+        min(vector) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = Math.min(vector[i2], this[i2]);
+          }
+          return this.check();
+        }
+        max(vector) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = Math.max(vector[i2], this[i2]);
+          }
+          return this.check();
+        }
+        clamp(minVector, maxVector) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = Math.min(Math.max(this[i2], minVector[i2]), maxVector[i2]);
+          }
+          return this.check();
+        }
+        add(...vectors) {
+          for (const vector of vectors) {
+            for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+              this[i2] += vector[i2];
+            }
+          }
+          return this.check();
+        }
+        subtract(...vectors) {
+          for (const vector of vectors) {
+            for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+              this[i2] -= vector[i2];
+            }
+          }
+          return this.check();
+        }
+        scale(scale2) {
+          if (typeof scale2 === "number") {
+            for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+              this[i2] *= scale2;
+            }
+          } else {
+            for (let i2 = 0; i2 < this.ELEMENTS && i2 < scale2.length; ++i2) {
+              this[i2] *= scale2[i2];
+            }
+          }
+          return this.check();
+        }
+        multiplyByScalar(scalar) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] *= scalar;
+          }
+          return this.check();
+        }
+        check() {
+          if (config.debug && !this.validate()) {
+            throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
+          }
+          return this;
+        }
+        validate() {
+          let valid = this.length === this.ELEMENTS;
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            valid = valid && Number.isFinite(this[i2]);
+          }
+          return valid;
+        }
+        sub(a2) {
+          return this.subtract(a2);
+        }
+        setScalar(a2) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = a2;
+          }
+          return this.check();
+        }
+        addScalar(a2) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] += a2;
+          }
+          return this.check();
+        }
+        subScalar(a2) {
+          return this.addScalar(-a2);
+        }
+        multiplyScalar(scalar) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] *= scalar;
+          }
+          return this.check();
+        }
+        divideScalar(a2) {
+          return this.multiplyByScalar(1 / a2);
+        }
+        clampScalar(min, max) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = Math.min(Math.max(this[i2], min), max);
+          }
+          return this.check();
+        }
+        get elements() {
+          return this;
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/lib/validators.js
+  function validateVector(v, length) {
+    if (v.length !== length) {
+      return false;
+    }
+    for (let i2 = 0; i2 < v.length; ++i2) {
+      if (!Number.isFinite(v[i2])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function checkNumber(value) {
+    if (!Number.isFinite(value)) {
+      throw new Error("Invalid number ".concat(value));
+    }
+    return value;
+  }
+  function checkVector(v, length, callerName = "") {
+    if (config.debug && !validateVector(v, length)) {
+      throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'"));
+    }
+    return v;
+  }
+  var init_validators = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/lib/validators.js"() {
+      init_common();
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/classes/base/vector.js
+  var Vector;
+  var init_vector = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/classes/base/vector.js"() {
+      init_math_array();
+      init_validators();
+      init_assert4();
+      Vector = class extends MathArray {
+        get x() {
+          return this[0];
+        }
+        set x(value) {
+          this[0] = checkNumber(value);
+        }
+        get y() {
+          return this[1];
+        }
+        set y(value) {
+          this[1] = checkNumber(value);
+        }
+        len() {
+          return Math.sqrt(this.lengthSquared());
+        }
+        magnitude() {
+          return this.len();
+        }
+        lengthSquared() {
+          let length = 0;
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            length += this[i2] * this[i2];
+          }
+          return length;
+        }
+        magnitudeSquared() {
+          return this.lengthSquared();
+        }
+        distance(mathArray) {
+          return Math.sqrt(this.distanceSquared(mathArray));
+        }
+        distanceSquared(mathArray) {
+          let length = 0;
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            const dist = this[i2] - mathArray[i2];
+            length += dist * dist;
+          }
+          return checkNumber(length);
+        }
+        dot(mathArray) {
+          let product = 0;
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            product += this[i2] * mathArray[i2];
+          }
+          return checkNumber(product);
+        }
+        normalize() {
+          const length = this.magnitude();
+          if (length !== 0) {
+            for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+              this[i2] /= length;
+            }
+          }
+          return this.check();
+        }
+        multiply(...vectors) {
+          for (const vector of vectors) {
+            for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+              this[i2] *= vector[i2];
+            }
+          }
+          return this.check();
+        }
+        divide(...vectors) {
+          for (const vector of vectors) {
+            for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+              this[i2] /= vector[i2];
+            }
+          }
+          return this.check();
+        }
+        lengthSq() {
+          return this.lengthSquared();
+        }
+        distanceTo(vector) {
+          return this.distance(vector);
+        }
+        distanceToSquared(vector) {
+          return this.distanceSquared(vector);
+        }
+        getComponent(i2) {
+          assert4(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
+          return checkNumber(this[i2]);
+        }
+        setComponent(i2, value) {
+          assert4(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
+          this[i2] = value;
+          return this.check();
+        }
+        addVectors(a2, b) {
+          return this.copy(a2).add(b);
+        }
+        subVectors(a2, b) {
+          return this.copy(a2).subtract(b);
+        }
+        multiplyVectors(a2, b) {
+          return this.copy(a2).multiply(b);
+        }
+        addScaledVector(a2, b) {
+          return this.add(new this.constructor(a2).multiplyScalar(b));
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/gl-matrix/esm/common.js
+  var ARRAY_TYPE, degree;
+  var init_common2 = __esm({
+    "../../node_modules/gl-matrix/esm/common.js"() {
+      ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
+      degree = Math.PI / 180;
+      if (!Math.hypot)
+        Math.hypot = function() {
+          var y = 0, i2 = arguments.length;
+          while (i2--) {
+            y += arguments[i2] * arguments[i2];
+          }
+          return Math.sqrt(y);
+        };
+    }
+  });
+
+  // ../../node_modules/gl-matrix/esm/vec2.js
+  function create() {
+    var out = new ARRAY_TYPE(2);
+    if (ARRAY_TYPE != Float32Array) {
+      out[0] = 0;
+      out[1] = 0;
+    }
+    return out;
+  }
+  function transformMat3(out, a2, m) {
+    var x = a2[0], y = a2[1];
+    out[0] = m[0] * x + m[3] * y + m[6];
+    out[1] = m[1] * x + m[4] * y + m[7];
+    return out;
+  }
+  var forEach;
+  var init_vec2 = __esm({
+    "../../node_modules/gl-matrix/esm/vec2.js"() {
+      init_common2();
+      forEach = function() {
+        var vec = create();
+        return function(a2, stride, offset, count, fn, arg) {
+          var i2, l2;
+          if (!stride) {
+            stride = 2;
+          }
+          if (!offset) {
+            offset = 0;
+          }
+          if (count) {
+            l2 = Math.min(count * stride + offset, a2.length);
+          } else {
+            l2 = a2.length;
+          }
+          for (i2 = offset; i2 < l2; i2 += stride) {
+            vec[0] = a2[i2];
+            vec[1] = a2[i2 + 1];
+            fn(vec, vec, arg);
+            a2[i2] = vec[0];
+            a2[i2 + 1] = vec[1];
+          }
+          return a2;
+        };
+      }();
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/lib/gl-matrix-extras.js
+  function vec3_transformMat4AsVector(out, a2, m) {
+    const x = a2[0];
+    const y = a2[1];
+    const z = a2[2];
+    const w = m[3] * x + m[7] * y + m[11] * z || 1;
+    out[0] = (m[0] * x + m[4] * y + m[8] * z) / w;
+    out[1] = (m[1] * x + m[5] * y + m[9] * z) / w;
+    out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;
+    return out;
+  }
+  function vec3_transformMat2(out, a2, m) {
+    const x = a2[0];
+    const y = a2[1];
+    out[0] = m[0] * x + m[2] * y;
+    out[1] = m[1] * x + m[3] * y;
+    out[2] = a2[2];
+    return out;
+  }
+  function vec4_transformMat3(out, a2, m) {
+    const x = a2[0];
+    const y = a2[1];
+    const z = a2[2];
+    out[0] = m[0] * x + m[3] * y + m[6] * z;
+    out[1] = m[1] * x + m[4] * y + m[7] * z;
+    out[2] = m[2] * x + m[5] * y + m[8] * z;
+    out[3] = a2[3];
+    return out;
+  }
+  var init_gl_matrix_extras = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/lib/gl-matrix-extras.js"() {
+    }
+  });
+
+  // ../../node_modules/gl-matrix/esm/vec3.js
+  function create2() {
+    var out = new ARRAY_TYPE(3);
+    if (ARRAY_TYPE != Float32Array) {
+      out[0] = 0;
+      out[1] = 0;
+      out[2] = 0;
+    }
+    return out;
+  }
+  function dot(a2, b) {
+    return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
+  }
+  function cross(out, a2, b) {
+    var ax = a2[0], ay = a2[1], az = a2[2];
+    var bx = b[0], by = b[1], bz = b[2];
+    out[0] = ay * bz - az * by;
+    out[1] = az * bx - ax * bz;
+    out[2] = ax * by - ay * bx;
+    return out;
+  }
+  function transformMat4(out, a2, m) {
+    var x = a2[0], y = a2[1], z = a2[2];
+    var w = m[3] * x + m[7] * y + m[11] * z + m[15];
+    w = w || 1;
+    out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+    out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+    out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+    return out;
+  }
+  function transformMat32(out, a2, m) {
+    var x = a2[0], y = a2[1], z = a2[2];
+    out[0] = x * m[0] + y * m[3] + z * m[6];
+    out[1] = x * m[1] + y * m[4] + z * m[7];
+    out[2] = x * m[2] + y * m[5] + z * m[8];
+    return out;
+  }
+  function transformQuat(out, a2, q) {
+    var qx = q[0], qy = q[1], qz = q[2], qw = q[3];
+    var x = a2[0], y = a2[1], z = a2[2];
+    var uvx = qy * z - qz * y, uvy = qz * x - qx * z, uvz = qx * y - qy * x;
+    var uuvx = qy * uvz - qz * uvy, uuvy = qz * uvx - qx * uvz, uuvz = qx * uvy - qy * uvx;
+    var w2 = qw * 2;
+    uvx *= w2;
+    uvy *= w2;
+    uvz *= w2;
+    uuvx *= 2;
+    uuvy *= 2;
+    uuvz *= 2;
+    out[0] = x + uvx + uuvx;
+    out[1] = y + uvy + uuvy;
+    out[2] = z + uvz + uuvz;
+    return out;
+  }
+  function rotateX(out, a2, b, rad) {
+    var p2 = [], r2 = [];
+    p2[0] = a2[0] - b[0];
+    p2[1] = a2[1] - b[1];
+    p2[2] = a2[2] - b[2];
+    r2[0] = p2[0];
+    r2[1] = p2[1] * Math.cos(rad) - p2[2] * Math.sin(rad);
+    r2[2] = p2[1] * Math.sin(rad) + p2[2] * Math.cos(rad);
+    out[0] = r2[0] + b[0];
+    out[1] = r2[1] + b[1];
+    out[2] = r2[2] + b[2];
+    return out;
+  }
+  function rotateY(out, a2, b, rad) {
+    var p2 = [], r2 = [];
+    p2[0] = a2[0] - b[0];
+    p2[1] = a2[1] - b[1];
+    p2[2] = a2[2] - b[2];
+    r2[0] = p2[2] * Math.sin(rad) + p2[0] * Math.cos(rad);
+    r2[1] = p2[1];
+    r2[2] = p2[2] * Math.cos(rad) - p2[0] * Math.sin(rad);
+    out[0] = r2[0] + b[0];
+    out[1] = r2[1] + b[1];
+    out[2] = r2[2] + b[2];
+    return out;
+  }
+  function rotateZ(out, a2, b, rad) {
+    var p2 = [], r2 = [];
+    p2[0] = a2[0] - b[0];
+    p2[1] = a2[1] - b[1];
+    p2[2] = a2[2] - b[2];
+    r2[0] = p2[0] * Math.cos(rad) - p2[1] * Math.sin(rad);
+    r2[1] = p2[0] * Math.sin(rad) + p2[1] * Math.cos(rad);
+    r2[2] = p2[2];
+    out[0] = r2[0] + b[0];
+    out[1] = r2[1] + b[1];
+    out[2] = r2[2] + b[2];
+    return out;
+  }
+  function angle(a2, b) {
+    var ax = a2[0], ay = a2[1], az = a2[2], bx = b[0], by = b[1], bz = b[2], mag1 = Math.sqrt(ax * ax + ay * ay + az * az), mag2 = Math.sqrt(bx * bx + by * by + bz * bz), mag = mag1 * mag2, cosine = mag && dot(a2, b) / mag;
+    return Math.acos(Math.min(Math.max(cosine, -1), 1));
+  }
+  var forEach2;
+  var init_vec3 = __esm({
+    "../../node_modules/gl-matrix/esm/vec3.js"() {
+      init_common2();
+      forEach2 = function() {
+        var vec = create2();
+        return function(a2, stride, offset, count, fn, arg) {
+          var i2, l2;
+          if (!stride) {
+            stride = 3;
+          }
+          if (!offset) {
+            offset = 0;
+          }
+          if (count) {
+            l2 = Math.min(count * stride + offset, a2.length);
+          } else {
+            l2 = a2.length;
+          }
+          for (i2 = offset; i2 < l2; i2 += stride) {
+            vec[0] = a2[i2];
+            vec[1] = a2[i2 + 1];
+            vec[2] = a2[i2 + 2];
+            fn(vec, vec, arg);
+            a2[i2] = vec[0];
+            a2[i2 + 1] = vec[1];
+            a2[i2 + 2] = vec[2];
+          }
+          return a2;
+        };
+      }();
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/classes/vector3.js
+  var ORIGIN, ZERO, Vector3;
+  var init_vector3 = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/classes/vector3.js"() {
+      init_vector();
+      init_common();
+      init_validators();
+      init_vec3();
+      init_gl_matrix_extras();
+      ORIGIN = [0, 0, 0];
+      Vector3 = class extends Vector {
+        static get ZERO() {
+          if (!ZERO) {
+            ZERO = new Vector3(0, 0, 0);
+            Object.freeze(ZERO);
+          }
+          return ZERO;
+        }
+        constructor(x = 0, y = 0, z = 0) {
+          super(-0, -0, -0);
+          if (arguments.length === 1 && isArray(x)) {
+            this.copy(x);
+          } else {
+            if (config.debug) {
+              checkNumber(x);
+              checkNumber(y);
+              checkNumber(z);
+            }
+            this[0] = x;
+            this[1] = y;
+            this[2] = z;
+          }
+        }
+        set(x, y, z) {
+          this[0] = x;
+          this[1] = y;
+          this[2] = z;
+          return this.check();
+        }
+        copy(array) {
+          this[0] = array[0];
+          this[1] = array[1];
+          this[2] = array[2];
+          return this.check();
+        }
+        fromObject(object) {
+          if (config.debug) {
+            checkNumber(object.x);
+            checkNumber(object.y);
+            checkNumber(object.z);
+          }
+          this[0] = object.x;
+          this[1] = object.y;
+          this[2] = object.z;
+          return this.check();
+        }
+        toObject(object) {
+          object.x = this[0];
+          object.y = this[1];
+          object.z = this[2];
+          return object;
+        }
+        get ELEMENTS() {
+          return 3;
+        }
+        get z() {
+          return this[2];
+        }
+        set z(value) {
+          this[2] = checkNumber(value);
+        }
+        angle(vector) {
+          return angle(this, vector);
+        }
+        cross(vector) {
+          cross(this, this, vector);
+          return this.check();
+        }
+        rotateX({
+          radians,
+          origin = ORIGIN
+        }) {
+          rotateX(this, this, origin, radians);
+          return this.check();
+        }
+        rotateY({
+          radians,
+          origin = ORIGIN
+        }) {
+          rotateY(this, this, origin, radians);
+          return this.check();
+        }
+        rotateZ({
+          radians,
+          origin = ORIGIN
+        }) {
+          rotateZ(this, this, origin, radians);
+          return this.check();
+        }
+        transform(matrix4) {
+          return this.transformAsPoint(matrix4);
+        }
+        transformAsPoint(matrix4) {
+          transformMat4(this, this, matrix4);
+          return this.check();
+        }
+        transformAsVector(matrix4) {
+          vec3_transformMat4AsVector(this, this, matrix4);
+          return this.check();
+        }
+        transformByMatrix3(matrix3) {
+          transformMat32(this, this, matrix3);
+          return this.check();
+        }
+        transformByMatrix2(matrix2) {
+          vec3_transformMat2(this, this, matrix2);
+          return this.check();
+        }
+        transformByQuaternion(quaternion) {
+          transformQuat(this, this, quaternion);
+          return this.check();
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/classes/base/matrix.js
+  var Matrix;
+  var init_matrix = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/classes/base/matrix.js"() {
+      init_math_array();
+      init_validators();
+      init_common();
+      Matrix = class extends MathArray {
+        toString() {
+          let string = "[";
+          if (config.printRowMajor) {
+            string += "row-major:";
+            for (let row = 0; row < this.RANK; ++row) {
+              for (let col = 0; col < this.RANK; ++col) {
+                string += " ".concat(this[col * this.RANK + row]);
+              }
+            }
+          } else {
+            string += "column-major:";
+            for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+              string += " ".concat(this[i2]);
+            }
+          }
+          string += "]";
+          return string;
+        }
+        getElementIndex(row, col) {
+          return col * this.RANK + row;
+        }
+        getElement(row, col) {
+          return this[col * this.RANK + row];
+        }
+        setElement(row, col, value) {
+          this[col * this.RANK + row] = checkNumber(value);
+          return this;
+        }
+        getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) {
+          const firstIndex = columnIndex * this.RANK;
+          for (let i2 = 0; i2 < this.RANK; ++i2) {
+            result[i2] = this[firstIndex + i2];
+          }
+          return result;
+        }
+        setColumn(columnIndex, columnVector) {
+          const firstIndex = columnIndex * this.RANK;
+          for (let i2 = 0; i2 < this.RANK; ++i2) {
+            this[firstIndex + i2] = columnVector[i2];
+          }
+          return this;
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/gl-matrix/esm/mat3.js
+  function transpose(out, a2) {
+    if (out === a2) {
+      var a01 = a2[1], a02 = a2[2], a12 = a2[5];
+      out[1] = a2[3];
+      out[2] = a2[6];
+      out[3] = a01;
+      out[5] = a2[7];
+      out[6] = a02;
+      out[7] = a12;
+    } else {
+      out[0] = a2[0];
+      out[1] = a2[3];
+      out[2] = a2[6];
+      out[3] = a2[1];
+      out[4] = a2[4];
+      out[5] = a2[7];
+      out[6] = a2[2];
+      out[7] = a2[5];
+      out[8] = a2[8];
+    }
+    return out;
+  }
+  function invert(out, a2) {
+    var a00 = a2[0], a01 = a2[1], a02 = a2[2];
+    var a10 = a2[3], a11 = a2[4], a12 = a2[5];
+    var a20 = a2[6], a21 = a2[7], a22 = a2[8];
+    var b01 = a22 * a11 - a12 * a21;
+    var b11 = -a22 * a10 + a12 * a20;
+    var b21 = a21 * a10 - a11 * a20;
+    var det = a00 * b01 + a01 * b11 + a02 * b21;
+    if (!det) {
       return null;
     }
-    if (Array.isArray(array)) {
-      return new ArrayType(array);
-    }
-    if (convertTypedArrays && !(array instanceof ArrayType)) {
-      return new ArrayType(array);
+    det = 1 / det;
+    out[0] = b01 * det;
+    out[1] = (-a22 * a01 + a02 * a21) * det;
+    out[2] = (a12 * a01 - a02 * a11) * det;
+    out[3] = b11 * det;
+    out[4] = (a22 * a00 - a02 * a20) * det;
+    out[5] = (-a12 * a00 + a02 * a10) * det;
+    out[6] = b21 * det;
+    out[7] = (-a21 * a00 + a01 * a20) * det;
+    out[8] = (a11 * a00 - a01 * a10) * det;
+    return out;
+  }
+  function determinant(a2) {
+    var a00 = a2[0], a01 = a2[1], a02 = a2[2];
+    var a10 = a2[3], a11 = a2[4], a12 = a2[5];
+    var a20 = a2[6], a21 = a2[7], a22 = a2[8];
+    return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);
+  }
+  function multiply(out, a2, b) {
+    var a00 = a2[0], a01 = a2[1], a02 = a2[2];
+    var a10 = a2[3], a11 = a2[4], a12 = a2[5];
+    var a20 = a2[6], a21 = a2[7], a22 = a2[8];
+    var b00 = b[0], b01 = b[1], b02 = b[2];
+    var b10 = b[3], b11 = b[4], b12 = b[5];
+    var b20 = b[6], b21 = b[7], b22 = b[8];
+    out[0] = b00 * a00 + b01 * a10 + b02 * a20;
+    out[1] = b00 * a01 + b01 * a11 + b02 * a21;
+    out[2] = b00 * a02 + b01 * a12 + b02 * a22;
+    out[3] = b10 * a00 + b11 * a10 + b12 * a20;
+    out[4] = b10 * a01 + b11 * a11 + b12 * a21;
+    out[5] = b10 * a02 + b11 * a12 + b12 * a22;
+    out[6] = b20 * a00 + b21 * a10 + b22 * a20;
+    out[7] = b20 * a01 + b21 * a11 + b22 * a21;
+    out[8] = b20 * a02 + b21 * a12 + b22 * a22;
+    return out;
+  }
+  function translate(out, a2, v) {
+    var a00 = a2[0], a01 = a2[1], a02 = a2[2], a10 = a2[3], a11 = a2[4], a12 = a2[5], a20 = a2[6], a21 = a2[7], a22 = a2[8], x = v[0], y = v[1];
+    out[0] = a00;
+    out[1] = a01;
+    out[2] = a02;
+    out[3] = a10;
+    out[4] = a11;
+    out[5] = a12;
+    out[6] = x * a00 + y * a10 + a20;
+    out[7] = x * a01 + y * a11 + a21;
+    out[8] = x * a02 + y * a12 + a22;
+    return out;
+  }
+  function rotate(out, a2, rad) {
+    var a00 = a2[0], a01 = a2[1], a02 = a2[2], a10 = a2[3], a11 = a2[4], a12 = a2[5], a20 = a2[6], a21 = a2[7], a22 = a2[8], s2 = Math.sin(rad), c = Math.cos(rad);
+    out[0] = c * a00 + s2 * a10;
+    out[1] = c * a01 + s2 * a11;
+    out[2] = c * a02 + s2 * a12;
+    out[3] = c * a10 - s2 * a00;
+    out[4] = c * a11 - s2 * a01;
+    out[5] = c * a12 - s2 * a02;
+    out[6] = a20;
+    out[7] = a21;
+    out[8] = a22;
+    return out;
+  }
+  function scale(out, a2, v) {
+    var x = v[0], y = v[1];
+    out[0] = x * a2[0];
+    out[1] = x * a2[1];
+    out[2] = x * a2[2];
+    out[3] = y * a2[3];
+    out[4] = y * a2[4];
+    out[5] = y * a2[5];
+    out[6] = a2[6];
+    out[7] = a2[7];
+    out[8] = a2[8];
+    return out;
+  }
+  function fromQuat(out, q) {
+    var x = q[0], y = q[1], z = q[2], w = q[3];
+    var x2 = x + x;
+    var y2 = y + y;
+    var z2 = z + z;
+    var xx = x * x2;
+    var yx = y * x2;
+    var yy = y * y2;
+    var zx = z * x2;
+    var zy = z * y2;
+    var zz = z * z2;
+    var wx = w * x2;
+    var wy = w * y2;
+    var wz = w * z2;
+    out[0] = 1 - yy - zz;
+    out[3] = yx - wz;
+    out[6] = zx + wy;
+    out[1] = yx + wz;
+    out[4] = 1 - xx - zz;
+    out[7] = zy - wx;
+    out[2] = zx - wy;
+    out[5] = zy + wx;
+    out[8] = 1 - xx - yy;
+    return out;
+  }
+  var init_mat3 = __esm({
+    "../../node_modules/gl-matrix/esm/mat3.js"() {
     }
-    return array;
-  }
-  var init_gltf_attribute_utils = __esm({
-    "src/lib/gltf-utils/gltf-attribute-utils.ts"() {
-      init_gltf_utils();
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/classes/matrix3.js
+  function getZeroMatrix() {
+    if (!ZERO_MATRIX3) {
+      ZERO_MATRIX3 = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]);
+      Object.freeze(ZERO_MATRIX3);
+    }
+    return ZERO_MATRIX3;
+  }
+  function getIdentityMatrix() {
+    if (!IDENTITY_MATRIX3) {
+      IDENTITY_MATRIX3 = new Matrix3();
+      Object.freeze(IDENTITY_MATRIX3);
+    }
+    return IDENTITY_MATRIX3;
+  }
+  var INDICES, IDENTITY_MATRIX, Matrix3, ZERO_MATRIX3, IDENTITY_MATRIX3;
+  var init_matrix3 = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/classes/matrix3.js"() {
+      init_matrix();
+      init_validators();
+      init_gl_matrix_extras();
+      init_mat3();
+      init_vec2();
+      init_vec3();
+      (function(INDICES2) {
+        INDICES2[INDICES2["COL0ROW0"] = 0] = "COL0ROW0";
+        INDICES2[INDICES2["COL0ROW1"] = 1] = "COL0ROW1";
+        INDICES2[INDICES2["COL0ROW2"] = 2] = "COL0ROW2";
+        INDICES2[INDICES2["COL1ROW0"] = 3] = "COL1ROW0";
+        INDICES2[INDICES2["COL1ROW1"] = 4] = "COL1ROW1";
+        INDICES2[INDICES2["COL1ROW2"] = 5] = "COL1ROW2";
+        INDICES2[INDICES2["COL2ROW0"] = 6] = "COL2ROW0";
+        INDICES2[INDICES2["COL2ROW1"] = 7] = "COL2ROW1";
+        INDICES2[INDICES2["COL2ROW2"] = 8] = "COL2ROW2";
+      })(INDICES || (INDICES = {}));
+      IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+      Matrix3 = class extends Matrix {
+        static get IDENTITY() {
+          return getIdentityMatrix();
+        }
+        static get ZERO() {
+          return getZeroMatrix();
+        }
+        get ELEMENTS() {
+          return 9;
+        }
+        get RANK() {
+          return 3;
+        }
+        get INDICES() {
+          return INDICES;
+        }
+        constructor(array, ...args) {
+          super(-0, -0, -0, -0, -0, -0, -0, -0, -0);
+          if (arguments.length === 1 && Array.isArray(array)) {
+            this.copy(array);
+          } else if (args.length > 0) {
+            this.copy([array, ...args]);
+          } else {
+            this.identity();
+          }
+        }
+        copy(array) {
+          this[0] = array[0];
+          this[1] = array[1];
+          this[2] = array[2];
+          this[3] = array[3];
+          this[4] = array[4];
+          this[5] = array[5];
+          this[6] = array[6];
+          this[7] = array[7];
+          this[8] = array[8];
+          return this.check();
+        }
+        identity() {
+          return this.copy(IDENTITY_MATRIX);
+        }
+        fromObject(object) {
+          return this.check();
+        }
+        fromQuaternion(q) {
+          fromQuat(this, q);
+          return this.check();
+        }
+        set(m00, m10, m20, m01, m11, m21, m02, m12, m22) {
+          this[0] = m00;
+          this[1] = m10;
+          this[2] = m20;
+          this[3] = m01;
+          this[4] = m11;
+          this[5] = m21;
+          this[6] = m02;
+          this[7] = m12;
+          this[8] = m22;
+          return this.check();
+        }
+        setRowMajor(m00, m01, m02, m10, m11, m12, m20, m21, m22) {
+          this[0] = m00;
+          this[1] = m10;
+          this[2] = m20;
+          this[3] = m01;
+          this[4] = m11;
+          this[5] = m21;
+          this[6] = m02;
+          this[7] = m12;
+          this[8] = m22;
+          return this.check();
+        }
+        determinant() {
+          return determinant(this);
+        }
+        transpose() {
+          transpose(this, this);
+          return this.check();
+        }
+        invert() {
+          invert(this, this);
+          return this.check();
+        }
+        multiplyLeft(a2) {
+          multiply(this, a2, this);
+          return this.check();
+        }
+        multiplyRight(a2) {
+          multiply(this, this, a2);
+          return this.check();
+        }
+        rotate(radians) {
+          rotate(this, this, radians);
+          return this.check();
+        }
+        scale(factor) {
+          if (Array.isArray(factor)) {
+            scale(this, this, factor);
+          } else {
+            scale(this, this, [factor, factor]);
+          }
+          return this.check();
+        }
+        translate(vec) {
+          translate(this, this, vec);
+          return this.check();
+        }
+        transform(vector, result) {
+          let out;
+          switch (vector.length) {
+            case 2:
+              out = transformMat3(result || [-0, -0], vector, this);
+              break;
+            case 3:
+              out = transformMat32(result || [-0, -0, -0], vector, this);
+              break;
+            case 4:
+              out = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this);
+              break;
+            default:
+              throw new Error("Illegal vector");
+          }
+          checkVector(out, vector.length);
+          return out;
+        }
+        transformVector(vector, result) {
+          return this.transform(vector, result);
+        }
+        transformVector2(vector, result) {
+          return this.transform(vector, result);
+        }
+        transformVector3(vector, result) {
+          return this.transform(vector, result);
+        }
+      };
     }
   });
 
-  // src/lib/extensions/KHR_draco_mesh_compression.ts
-  var KHR_draco_mesh_compression_exports = {};
-  __export(KHR_draco_mesh_compression_exports, {
-    decode: () => decode3,
-    encode: () => encode,
-    name: () => name4,
-    preprocess: () => preprocess4
+  // ../../node_modules/@math.gl/core/dist/esm/index.js
+  var init_esm = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/index.js"() {
+      init_vector3();
+      init_matrix3();
+    }
   });
-  function preprocess4(gltfData, options, context) {
-    const scenegraph = new GLTFScenegraph(gltfData);
-    for (const primitive of makeMeshPrimitiveIterator(scenegraph)) {
-      if (scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION)) {
-      }
+
+  // src/lib/gltf-utils/gltf-constants.ts
+  var COMPONENTS, BYTES;
+  var init_gltf_constants = __esm({
+    "src/lib/gltf-utils/gltf-constants.ts"() {
+      COMPONENTS = {
+        SCALAR: 1,
+        VEC2: 2,
+        VEC3: 3,
+        VEC4: 4,
+        MAT2: 4,
+        MAT3: 9,
+        MAT4: 16
+      };
+      BYTES = {
+        5120: 1,
+        5121: 1,
+        5122: 2,
+        5123: 2,
+        5125: 4,
+        5126: 4
+      };
     }
-  }
-  async function decode3(gltfData, options, context) {
-    if (!options?.gltf?.decompressMeshes) {
+  });
+
+  // src/lib/extensions/KHR_texture_transform.ts
+  var KHR_texture_transform_exports = {};
+  __export(KHR_texture_transform_exports, {
+    decode: () => decode4,
+    name: () => name5
+  });
+  async function decode4(gltfData, options) {
+    const gltfScenegraph = new GLTFScenegraph(gltfData);
+    const extension = gltfScenegraph.getExtension(EXT_MESHOPT_TRANSFORM);
+    if (!extension) {
       return;
     }
-    const scenegraph = new GLTFScenegraph(gltfData);
-    const promises = [];
-    for (const primitive of makeMeshPrimitiveIterator(scenegraph)) {
-      if (scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION)) {
-        promises.push(decompressPrimitive(scenegraph, primitive, options, context));
-      }
+    const materials = gltfData.json.materials || [];
+    for (let i2 = 0; i2 < materials.length; i2++) {
+      transformTexCoords(i2, gltfData);
     }
-    await Promise.all(promises);
-    scenegraph.removeExtension(KHR_DRACO_MESH_COMPRESSION);
   }
-  function encode(gltfData, options = {}) {
-    const scenegraph = new GLTFScenegraph(gltfData);
-    for (const mesh of scenegraph.json.meshes || []) {
-      compressMesh(mesh, options);
-      scenegraph.addRequiredExtension(KHR_DRACO_MESH_COMPRESSION);
+  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);
     }
   }
-  async function decompressPrimitive(scenegraph, primitive, options, context) {
-    const dracoExtension = scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION);
-    if (!dracoExtension) {
+  function transformPrimitives(gltfData, materialIndex, texture, processedTexCoords) {
+    const transformParameters = getTransformParameters(texture, processedTexCoords);
+    if (!transformParameters) {
       return;
     }
-    const buffer = scenegraph.getTypedArrayForBufferView(dracoExtension.bufferView);
-    const bufferCopy = sliceArrayBuffer(buffer.buffer, buffer.byteOffset);
-    const { parse: parse4 } = context;
-    const dracoOptions = { ...options };
-    delete dracoOptions["3d-tiles"];
-    const decodedData = await parse4(bufferCopy, DracoLoader2, dracoOptions, context);
-    const decodedAttributes = getGLTFAccessors(decodedData.attributes);
-    for (const [attributeName, decodedAttribute] of Object.entries(decodedAttributes)) {
-      if (attributeName in primitive.attributes) {
-        const accessorIndex = primitive.attributes[attributeName];
-        const accessor = scenegraph.getAccessor(accessorIndex);
-        if (accessor?.min && accessor?.max) {
-          decodedAttribute.min = accessor.min;
-          decodedAttribute.max = accessor.max;
+    const meshes = gltfData.json.meshes || [];
+    for (const mesh of meshes) {
+      for (const primitive of mesh.primitives) {
+        const material = primitive.material;
+        if (Number.isFinite(material) && materialIndex === material) {
+          transformPrimitive(gltfData, primitive, transformParameters);
         }
       }
     }
-    primitive.attributes = decodedAttributes;
-    if (decodedData.indices) {
-      primitive.indices = getGLTFAccessor(decodedData.indices);
-    }
-    checkPrimitive(primitive);
   }
-  function compressMesh(attributes, indices, mode = 4, options, context) {
-    if (!options.DracoWriter) {
-      throw new Error("options.gltf.DracoWriter not provided");
+  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;
+    if (!isProcessed) {
+      const matrix = makeTransformationMatrix(textureInfo);
+      if (originalTexCoord !== texCoord) {
+        texture.texCoord = texCoord;
+      }
+      processedTexCoords.push([originalTexCoord, texCoord]);
+      return { originalTexCoord, texCoord, matrix };
     }
-    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
-            }
+    return null;
+  }
+  function transformPrimitive(gltfData, primitive, 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 byteOffset = (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);
+          const { ArrayType, length } = getAccessorArrayTypeAndLength(accessor, bufferView);
+          const bytes = BYTES[accessor.componentType];
+          const components = COMPONENTS[accessor.type];
+          const elementAddressScale = bufferView.byteStride || bytes * components;
+          const result = new Float32Array(length);
+          for (let i2 = 0; i2 < accessor.count; i2++) {
+            const uv = new ArrayType(arrayBuffer, byteOffset + i2 * elementAddressScale, 2);
+            scratchVector.set(uv[0], uv[1], 1);
+            scratchVector.transformByMatrix3(matrix);
+            result.set([scratchVector[0], scratchVector[1]], i2 * components);
+          }
+          if (originalTexCoord === texCoord) {
+            updateGltf(accessor, bufferView, gltfData.buffers, result);
+          } else {
+            createAttribute(texCoord, accessor, primitive, gltfData, result);
           }
         }
-      ]
-    };
-    return glTFMesh;
-  }
-  function checkPrimitive(primitive) {
-    if (!primitive.attributes && Object.keys(primitive.attributes).length > 0) {
-      throw new Error("glTF: Empty primitive detected: Draco decompression failure?");
-    }
-  }
-  function* makeMeshPrimitiveIterator(scenegraph) {
-    for (const mesh of scenegraph.json.meshes || []) {
-      for (const primitive of mesh.primitives) {
-        yield primitive;
       }
     }
   }
-  var KHR_DRACO_MESH_COMPRESSION, name4;
-  var init_KHR_draco_mesh_compression = __esm({
-    "src/lib/extensions/KHR_draco_mesh_compression.ts"() {
-      init_src6();
-      init_src2();
+  function updateGltf(accessor, bufferView, buffers, newTexCoordArray) {
+    accessor.componentType = 5126;
+    buffers.push({
+      arrayBuffer: newTexCoordArray.buffer,
+      byteOffset: 0,
+      byteLength: newTexCoordArray.buffer.byteLength
+    });
+    bufferView.buffer = buffers.length - 1;
+    bufferView.byteLength = newTexCoordArray.buffer.byteLength;
+    bufferView.byteOffset = 0;
+    delete bufferView.byteStride;
+  }
+  function createAttribute(newTexCoord, originalAccessor, primitive, gltfData, newTexCoordArray) {
+    gltfData.buffers.push({
+      arrayBuffer: newTexCoordArray.buffer,
+      byteOffset: 0,
+      byteLength: newTexCoordArray.buffer.byteLength
+    });
+    const bufferViews = gltfData.json.bufferViews;
+    if (!bufferViews) {
+      return;
+    }
+    bufferViews.push({
+      buffer: gltfData.buffers.length - 1,
+      byteLength: newTexCoordArray.buffer.byteLength,
+      byteOffset: 0
+    });
+    const accessors = gltfData.json.accessors;
+    if (!accessors) {
+      return;
+    }
+    accessors.push({
+      bufferView: bufferViews?.length - 1,
+      byteOffset: 0,
+      componentType: 5126,
+      count: originalAccessor.count,
+      type: "VEC2"
+    });
+    primitive.attributes[`TEXCOORD_${newTexCoord}`] = accessors.length - 1;
+  }
+  function makeTransformationMatrix(extensionData) {
+    const { offset = [0, 0], rotation = 0, scale: scale2 = [1, 1] } = extensionData;
+    const translationMatirx = new Matrix3().set(1, 0, 0, 0, 1, 0, offset[0], offset[1], 1);
+    const rotationMatirx = 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 translationMatirx.multiplyRight(rotationMatirx).multiplyRight(scaleMatrix);
+  }
+  var EXT_MESHOPT_TRANSFORM, name5, scratchVector, scratchRotationMatrix, scratchScaleMatrix;
+  var init_KHR_texture_transform = __esm({
+    "src/lib/extensions/KHR_texture_transform.ts"() {
+      init_esm();
+      init_gltf_utils();
+      init_gltf_constants();
       init_gltf_scenegraph();
-      init_gltf_attribute_utils();
-      KHR_DRACO_MESH_COMPRESSION = "KHR_draco_mesh_compression";
-      name4 = KHR_DRACO_MESH_COMPRESSION;
+      EXT_MESHOPT_TRANSFORM = "KHR_texture_transform";
+      name5 = EXT_MESHOPT_TRANSFORM;
+      scratchVector = new Vector3();
+      scratchRotationMatrix = new Matrix3();
+      scratchScaleMatrix = new Matrix3();
     }
   });
 
   // src/lib/extensions/deprecated/KHR_lights_punctual.ts
   var KHR_lights_punctual_exports = {};
   __export(KHR_lights_punctual_exports, {
-    decode: () => decode4,
+    decode: () => decode5,
     encode: () => encode2,
-    name: () => name5
+    name: () => name6
   });
-  async function decode4(gltfData) {
+  async function decode5(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
     const extension = gltfScenegraph.getExtension(KHR_LIGHTS_PUNCTUAL);
@@ -3351,27 +4277,26 @@
       delete gltfScenegraph.json.lights;
     }
   }
-  var KHR_LIGHTS_PUNCTUAL, name5;
+  var KHR_LIGHTS_PUNCTUAL, name6;
   var init_KHR_lights_punctual = __esm({
     "src/lib/extensions/deprecated/KHR_lights_punctual.ts"() {
       init_assert3();
       init_gltf_scenegraph();
       KHR_LIGHTS_PUNCTUAL = "KHR_lights_punctual";
-      name5 = KHR_LIGHTS_PUNCTUAL;
+      name6 = KHR_LIGHTS_PUNCTUAL;
     }
   });
 
   // src/lib/extensions/deprecated/KHR_materials_unlit.ts
   var KHR_materials_unlit_exports = {};
   __export(KHR_materials_unlit_exports, {
-    decode: () => decode5,
+    decode: () => decode6,
     encode: () => encode3,
-    name: () => name6
+    name: () => name7
   });
-  async function decode5(gltfData) {
+  async function decode6(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
-    gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);
     for (const material of json.materials || []) {
       const extension = material.extensions && material.extensions.KHR_materials_unlit;
       if (extension) {
@@ -3379,6 +4304,7 @@
       }
       gltfScenegraph.removeObjectExtension(material, KHR_MATERIALS_UNLIT);
     }
+    gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);
   }
   function encode3(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
@@ -3393,23 +4319,23 @@
       }
     }
   }
-  var KHR_MATERIALS_UNLIT, name6;
+  var KHR_MATERIALS_UNLIT, name7;
   var init_KHR_materials_unlit = __esm({
     "src/lib/extensions/deprecated/KHR_materials_unlit.ts"() {
       init_gltf_scenegraph();
       KHR_MATERIALS_UNLIT = "KHR_materials_unlit";
-      name6 = KHR_MATERIALS_UNLIT;
+      name7 = KHR_MATERIALS_UNLIT;
     }
   });
 
   // src/lib/extensions/deprecated/KHR_techniques_webgl.ts
   var KHR_techniques_webgl_exports = {};
   __export(KHR_techniques_webgl_exports, {
-    decode: () => decode6,
+    decode: () => decode7,
     encode: () => encode4,
-    name: () => name7
+    name: () => name8
   });
-  async function decode6(gltfData) {
+  async function decode7(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
     const extension = gltfScenegraph.getExtension(KHR_TECHNIQUES_WEBGL);
@@ -3461,12 +4387,97 @@
     });
     return values;
   }
-  var KHR_TECHNIQUES_WEBGL, name7;
+  var KHR_TECHNIQUES_WEBGL, name8;
   var init_KHR_techniques_webgl = __esm({
     "src/lib/extensions/deprecated/KHR_techniques_webgl.ts"() {
       init_gltf_scenegraph();
       KHR_TECHNIQUES_WEBGL = "KHR_techniques_webgl";
-      name7 = KHR_TECHNIQUES_WEBGL;
+      name8 = KHR_TECHNIQUES_WEBGL;
+    }
+  });
+
+  // src/lib/extensions/deprecated/EXT_feature_metadata.ts
+  var EXT_feature_metadata_exports = {};
+  __export(EXT_feature_metadata_exports, {
+    decode: () => decode8,
+    name: () => name9
+  });
+  async function decode8(gltfData) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    decodeExtFeatureMetadata(scenegraph);
+  }
+  function decodeExtFeatureMetadata(scenegraph) {
+    const extension = scenegraph.getExtension(EXT_FEATURE_METADATA);
+    const schemaClasses = extension?.schema?.classes;
+    const featureTables = extension?.featureTables;
+    const featureTextures = extension?.featureTextures;
+    if (featureTextures) {
+      console.warn('featureTextures is not yet supported in the "EXT_feature_metadata" extension.');
+    }
+    if (schemaClasses && featureTables) {
+      for (const schemaName in schemaClasses) {
+        const schemaClass = schemaClasses[schemaName];
+        const featureTable = findFeatureTableByName(featureTables, schemaName);
+        if (featureTable) {
+          handleFeatureTableProperties(scenegraph, featureTable, schemaClass);
+        }
+      }
+    }
+  }
+  function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
+    for (const propertyName in schemaClass.properties) {
+      const schemaProperty = schemaClass.properties[propertyName];
+      const featureTableProperty = featureTable?.properties?.[propertyName];
+      const numberOfFeatures = featureTable.count;
+      if (featureTableProperty) {
+        const data = getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty);
+        featureTableProperty.data = data;
+      }
+    }
+  }
+  function getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
+    const bufferView = featureTableProperty.bufferView;
+    let data = scenegraph.getTypedArrayForBufferView(bufferView);
+    switch (schemaProperty.type) {
+      case "STRING": {
+        const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView;
+        const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
+        data = getStringAttributes(data, offsetsData, numberOfFeatures);
+        break;
+      }
+      default:
+    }
+    return data;
+  }
+  function findFeatureTableByName(featureTables, schemaClassName) {
+    for (const featureTableName in featureTables) {
+      const featureTable = featureTables[featureTableName];
+      if (featureTable.class === schemaClassName) {
+        return featureTable;
+      }
+    }
+    return null;
+  }
+  function getStringAttributes(data, offsetsData, stringsCount) {
+    const stringsArray = [];
+    const textDecoder = new TextDecoder("utf8");
+    let stringOffset = 0;
+    const bytesPerStringSize = 4;
+    for (let index = 0; index < stringsCount; index++) {
+      const stringByteSize = offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];
+      const stringData = data.subarray(stringOffset, stringByteSize + stringOffset);
+      const stringAttribute = textDecoder.decode(stringData);
+      stringsArray.push(stringAttribute);
+      stringOffset += stringByteSize;
+    }
+    return stringsArray;
+  }
+  var EXT_FEATURE_METADATA, name9;
+  var init_EXT_feature_metadata = __esm({
+    "src/lib/extensions/deprecated/EXT_feature_metadata.ts"() {
+      init_gltf_scenegraph();
+      EXT_FEATURE_METADATA = "EXT_feature_metadata";
+      name9 = EXT_FEATURE_METADATA;
     }
   });
 
@@ -3495,9 +4506,11 @@
       init_EXT_texture_webp();
       init_KHR_texture_basisu();
       init_KHR_draco_mesh_compression();
+      init_KHR_texture_transform();
       init_KHR_lights_punctual();
       init_KHR_materials_unlit();
       init_KHR_techniques_webgl();
+      init_EXT_feature_metadata();
       EXTENSIONS2 = [
         EXT_meshopt_compression_exports,
         EXT_texture_webp_exports,
@@ -3505,13 +4518,15 @@
         KHR_draco_mesh_compression_exports,
         KHR_lights_punctual_exports,
         KHR_materials_unlit_exports,
-        KHR_techniques_webgl_exports
+        KHR_techniques_webgl_exports,
+        KHR_texture_transform_exports,
+        EXT_feature_metadata_exports
       ];
     }
   });
 
   // src/lib/extensions/KHR_binary_gltf.ts
-  function preprocess5(gltfData) {
+  function preprocess4(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
     for (const image of json.images || []) {
@@ -3606,7 +4621,7 @@
           console.warn("Converting glTF v1 to glTF v2 format. This is experimental and may fail.");
           this._addAsset(json);
           this._convertTopLevelObjectsToArrays(json);
-          preprocess5(gltf);
+          preprocess4(gltf);
           this._convertObjectIdsToArrayIndices(json);
           this._updateObjects(json);
           this._updateMaterial(json);
@@ -3723,7 +4738,7 @@
               metallicFactor: 1,
               roughnessFactor: 1
             };
-            const textureId = material.values && material.values.tex;
+            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 };
@@ -3736,20 +4751,20 @@
 
   // src/lib/api/post-process-gltf.ts
   function getBytesFromComponentType(componentType) {
-    return BYTES[componentType];
+    return BYTES2[componentType];
   }
   function getSizeFromAccessorType(type) {
-    return COMPONENTS[type];
+    return COMPONENTS2[type];
   }
   function postProcessGLTF(gltf, options) {
     return new GLTFPostProcessor().postProcess(gltf, options);
   }
-  var COMPONENTS, BYTES, GL_SAMPLER, SAMPLER_PARAMETER_GLTF_TO_GL, DEFAULT_SAMPLER, GLTFPostProcessor;
+  var COMPONENTS2, BYTES2, GL_SAMPLER, SAMPLER_PARAMETER_GLTF_TO_GL, DEFAULT_SAMPLER, GLTFPostProcessor;
   var init_post_process_gltf = __esm({
     "src/lib/api/post-process-gltf.ts"() {
       init_assert3();
       init_gltf_utils();
-      COMPONENTS = {
+      COMPONENTS2 = {
         SCALAR: 1,
         VEC2: 2,
         VEC3: 3,
@@ -3758,7 +4773,7 @@
         MAT3: 9,
         MAT4: 16
       };
-      BYTES = {
+      BYTES2 = {
         5120: 1,
         5121: 1,
         5122: 2,
@@ -4093,18 +5108,18 @@
     }
   }
   function parseGLBV1(glb, dataView, byteOffset) {
-    assert2(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+    assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
     const contentLength = dataView.getUint32(byteOffset + 0, LE);
     const contentFormat = dataView.getUint32(byteOffset + 4, LE);
     byteOffset += GLB_CHUNK_HEADER_SIZE;
-    assert2(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);
+    assert(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);
     parseJSONChunk(glb, dataView, byteOffset, contentLength);
     byteOffset += contentLength;
     byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);
     return byteOffset;
   }
   function parseGLBV2(glb, dataView, byteOffset, options) {
-    assert2(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+    assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
     parseGLBChunksSync(glb, dataView, byteOffset, options);
     return byteOffset + glb.header.byteLength;
   }
@@ -4235,6 +5250,12 @@
           byteLength: arrayBuffer.byteLength
         };
         delete buffer.uri;
+      } else if (gltf.buffers[i2] === null) {
+        gltf.buffers[i2] = {
+          arrayBuffer: new ArrayBuffer(buffer.byteLength),
+          byteOffset: 0,
+          byteLength: buffer.byteLength
+        };
       }
     }
   }
@@ -4260,10 +5281,13 @@
   async function loadImage(gltf, image, index, options, context) {
     const { fetch: fetch2, parse: parse4 } = context;
     let arrayBuffer;
-    if (image.uri) {
+    if (image.uri && !image.hasOwnProperty("bufferView")) {
       const uri = resolveUrl(image.uri, options);
       const response = await fetch2(uri);
       arrayBuffer = await response.arrayBuffer();
+      image.bufferView = {
+        data: arrayBuffer
+      };
     }
     if (Number.isFinite(image.bufferView)) {
       const array = getTypedArrayForBufferView(gltf.json, gltf.buffers, image.bufferView);
@@ -4490,8 +5514,8 @@
   var GLBWriter;
   var init_glb_writer = __esm({
     "src/glb-writer.ts"() {
-      init_version();
       init_encode_glb();
+      init_version();
       GLBWriter = {
         name: "GLB",
         id: "glb",