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

package/dist/dist.min.js

@@ -200,7 +200,6 @@
   // ../worker-utils/src/index.ts
   var init_src = __esm({
     "../worker-utils/src/index.ts"() {
-      init_globals2();
       init_library_utils();
     }
   });
@@ -321,788 +320,325 @@
     }
   });
 
-  // ../textures/src/lib/utils/version.ts
+  // ../images/src/lib/utils/version.ts
   var VERSION4;
   var init_version3 = __esm({
-    "../textures/src/lib/utils/version.ts"() {
-      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+    "../images/src/lib/utils/version.ts"() {
+      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
-  // ../textures/src/lib/parsers/basis-module-loader.ts
-  async function loadBasisTrascoderModule(options) {
-    const modules = options.modules || {};
-    if (modules.basis) {
-      return modules.basis;
+  // ../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`);
     }
-    loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTrascoder(options);
-    return await loadBasisTranscoderPromise;
-  }
-  async function loadBasisTrascoder(options) {
-    let BASIS = null;
-    let wasmBinary = null;
-    [BASIS, wasmBinary] = await Promise.all([
-      await loadLibrary("basis_transcoder.js", "textures", options),
-      await loadLibrary("basis_transcoder.wasm", "textures", options)
-    ]);
-    BASIS = BASIS || globalThis.BASIS;
-    return await initializeBasisTrascoderModule(BASIS, wasmBinary);
   }
-  function initializeBasisTrascoderModule(BasisModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
+  function getDefaultImageType() {
+    if (IMAGE_BITMAP_SUPPORTED) {
+      return "imagebitmap";
     }
-    return new Promise((resolve) => {
-      BasisModule(options).then((module) => {
-        const { BasisFile, initializeBasis } = module;
-        initializeBasis();
-        resolve({ BasisFile });
-      });
-    });
-  }
-  async function loadBasisEncoderModule(options) {
-    const modules = options.modules || {};
-    if (modules.basisEncoder) {
-      return modules.basisEncoder;
+    if (IMAGE_SUPPORTED) {
+      return "image";
     }
-    loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
-    return await loadBasisEncoderPromise;
-  }
-  async function loadBasisEncoder(options) {
-    let BASIS_ENCODER = null;
-    let wasmBinary = null;
-    [BASIS_ENCODER, wasmBinary] = await Promise.all([
-      await loadLibrary(BASIS_CDN_ENCODER_JS, "textures", options),
-      await loadLibrary(BASIS_CDN_ENCODER_WASM, "textures", options)
-    ]);
-    BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
-    return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
-  }
-  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
+    if (DATA_SUPPORTED) {
+      return "data";
     }
-    return new Promise((resolve) => {
-      BasisEncoderModule(options).then((module) => {
-        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
-        initializeBasis();
-        resolve({ BasisFile, KTX2File, BasisEncoder });
-      });
-    });
+    throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js");
   }
-  var VERSION5, BASIS_CDN_ENCODER_WASM, BASIS_CDN_ENCODER_JS, loadBasisTranscoderPromise, loadBasisEncoderPromise;
-  var init_basis_module_loader = __esm({
-    "../textures/src/lib/parsers/basis-module-loader.ts"() {
-      init_src();
-      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
-      BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION5}/dist/libs/basis_encoder.wasm`;
-      BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION5}/dist/libs/basis_encoder.js`;
+  var _parseImageNode, IMAGE_SUPPORTED, IMAGE_BITMAP_SUPPORTED, NODE_IMAGE_SUPPORTED, DATA_SUPPORTED;
+  var init_image_type = __esm({
+    "../images/src/lib/category-api/image-type.ts"() {
+      init_src2();
+      ({ _parseImageNode } = globalThis);
+      IMAGE_SUPPORTED = typeof Image !== "undefined";
+      IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
+      NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);
+      DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;
     }
   });
 
-  // ../textures/src/lib/gl-extensions.ts
-  var GL_EXTENSIONS_CONSTANTS;
-  var init_gl_extensions = __esm({
-    "../textures/src/lib/gl-extensions.ts"() {
-      GL_EXTENSIONS_CONSTANTS = {
-        COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
-        COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
-        COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
-        COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
-        COMPRESSED_R11_EAC: 37488,
-        COMPRESSED_SIGNED_R11_EAC: 37489,
-        COMPRESSED_RG11_EAC: 37490,
-        COMPRESSED_SIGNED_RG11_EAC: 37491,
-        COMPRESSED_RGB8_ETC2: 37492,
-        COMPRESSED_RGBA8_ETC2_EAC: 37493,
-        COMPRESSED_SRGB8_ETC2: 37494,
-        COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37495,
-        COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37496,
-        COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37497,
-        COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
-        COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
-        COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
-        COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
-        COMPRESSED_RGB_ETC1_WEBGL: 36196,
-        COMPRESSED_RGB_ATC_WEBGL: 35986,
-        COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35987,
-        COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798,
-        COMPRESSED_RGBA_ASTC_4X4_KHR: 37808,
-        COMPRESSED_RGBA_ASTC_5X4_KHR: 37809,
-        COMPRESSED_RGBA_ASTC_5X5_KHR: 37810,
-        COMPRESSED_RGBA_ASTC_6X5_KHR: 37811,
-        COMPRESSED_RGBA_ASTC_6X6_KHR: 37812,
-        COMPRESSED_RGBA_ASTC_8X5_KHR: 37813,
-        COMPRESSED_RGBA_ASTC_8X6_KHR: 37814,
-        COMPRESSED_RGBA_ASTC_8X8_KHR: 37815,
-        COMPRESSED_RGBA_ASTC_10X5_KHR: 37816,
-        COMPRESSED_RGBA_ASTC_10X6_KHR: 37817,
-        COMPRESSED_RGBA_ASTC_10X8_KHR: 37818,
-        COMPRESSED_RGBA_ASTC_10X10_KHR: 37819,
-        COMPRESSED_RGBA_ASTC_12X10_KHR: 37820,
-        COMPRESSED_RGBA_ASTC_12X12_KHR: 37821,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR: 37840,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR: 37841,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR: 37842,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR: 37843,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR: 37844,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR: 37845,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR: 37846,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR: 37847,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR: 37848,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR: 37849,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR: 37850,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR: 37851,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR: 37852,
-        COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR: 37853,
-        COMPRESSED_RED_RGTC1_EXT: 36283,
-        COMPRESSED_SIGNED_RED_RGTC1_EXT: 36284,
-        COMPRESSED_RED_GREEN_RGTC2_EXT: 36285,
-        COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 36286,
-        COMPRESSED_SRGB_S3TC_DXT1_EXT: 35916,
-        COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 35917,
-        COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 35918,
-        COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 35919
-      };
+  // ../images/src/lib/category-api/parsed-image-api.ts
+  function getImageType(image) {
+    const format = getImageTypeOrNull(image);
+    if (!format) {
+      throw new Error("Not an image");
     }
-  });
-
-  // ../textures/src/lib/utils/texture-formats.ts
-  function getSupportedGPUTextureFormats(gl) {
-    if (!formats) {
-      gl = gl || getWebGLContext() || void 0;
-      formats = new Set();
-      for (const prefix of BROWSER_PREFIXES) {
-        for (const extension in WEBGL_EXTENSIONS) {
-          if (gl && gl.getExtension(`${prefix}${extension}`)) {
-            const gpuTextureFormat = WEBGL_EXTENSIONS[extension];
-            formats.add(gpuTextureFormat);
-          }
+    return format;
+  }
+  function getImageData(image) {
+    switch (getImageType(image)) {
+      case "data":
+        return image;
+      case "image":
+      case "imagebitmap":
+        const canvas = document.createElement("canvas");
+        const context = canvas.getContext("2d");
+        if (!context) {
+          throw new Error("getImageData");
         }
-      }
+        canvas.width = image.width;
+        canvas.height = image.height;
+        context.drawImage(image, 0, 0);
+        return context.getImageData(0, 0, image.width, image.height);
+      default:
+        throw new Error("getImageData");
     }
-    return formats;
   }
-  function getWebGLContext() {
-    try {
-      const canvas = document.createElement("canvas");
-      return canvas.getContext("webgl");
-    } catch (error) {
-      return null;
+  function getImageTypeOrNull(image) {
+    if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
+      return "imagebitmap";
     }
-  }
-  var BROWSER_PREFIXES, WEBGL_EXTENSIONS, formats;
-  var init_texture_formats = __esm({
-    "../textures/src/lib/utils/texture-formats.ts"() {
-      BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
-      WEBGL_EXTENSIONS = {
-        WEBGL_compressed_texture_s3tc: "dxt",
-        WEBGL_compressed_texture_s3tc_srgb: "dxt-srgb",
-        WEBGL_compressed_texture_etc1: "etc1",
-        WEBGL_compressed_texture_etc: "etc2",
-        WEBGL_compressed_texture_pvrtc: "pvrtc",
-        WEBGL_compressed_texture_atc: "atc",
-        WEBGL_compressed_texture_astc: "astc",
-        EXT_texture_compression_rgtc: "rgtc"
-      };
-      formats = null;
+    if (typeof Image !== "undefined" && image instanceof Image) {
+      return "image";
     }
-  });
-
-  // ../../node_modules/ktx-parse/dist/ktx-parse.modern.js
-  var t, n, i, s, a, r, o, l, f;
-  var init_ktx_parse_modern = __esm({
-    "../../node_modules/ktx-parse/dist/ktx-parse.modern.js"() {
-      t = new Uint8Array([0]);
-      !function(t2) {
-        t2[t2.NONE = 0] = "NONE", t2[t2.BASISLZ = 1] = "BASISLZ", t2[t2.ZSTD = 2] = "ZSTD", t2[t2.ZLIB = 3] = "ZLIB";
-      }(n || (n = {})), function(t2) {
-        t2[t2.BASICFORMAT = 0] = "BASICFORMAT";
-      }(i || (i = {})), function(t2) {
-        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.ETC1S = 163] = "ETC1S", t2[t2.UASTC = 166] = "UASTC";
-      }(s || (s = {})), function(t2) {
-        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.SRGB = 1] = "SRGB";
-      }(a || (a = {})), function(t2) {
-        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.LINEAR = 1] = "LINEAR", t2[t2.SRGB = 2] = "SRGB", t2[t2.ITU = 3] = "ITU", t2[t2.NTSC = 4] = "NTSC", t2[t2.SLOG = 5] = "SLOG", t2[t2.SLOG2 = 6] = "SLOG2";
-      }(r || (r = {})), function(t2) {
-        t2[t2.ALPHA_STRAIGHT = 0] = "ALPHA_STRAIGHT", t2[t2.ALPHA_PREMULTIPLIED = 1] = "ALPHA_PREMULTIPLIED";
-      }(o || (o = {})), function(t2) {
-        t2[t2.RGB = 0] = "RGB", t2[t2.RRR = 3] = "RRR", t2[t2.GGG = 4] = "GGG", t2[t2.AAA = 15] = "AAA";
-      }(l || (l = {})), function(t2) {
-        t2[t2.RGB = 0] = "RGB", t2[t2.RGBA = 3] = "RGBA", t2[t2.RRR = 4] = "RRR", t2[t2.RRRG = 5] = "RRRG";
-      }(f || (f = {}));
+    if (image && typeof image === "object" && image.data && image.width && image.height) {
+      return "data";
+    }
+    return null;
+  }
+  var init_parsed_image_api = __esm({
+    "../images/src/lib/category-api/parsed-image-api.ts"() {
     }
   });
 
-  // ../textures/src/lib/parsers/parse-ktx.ts
-  function isKTX(data) {
-    const id = new Uint8Array(data);
-    const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || id[1] !== KTX2_ID[1] || id[2] !== KTX2_ID[2] || id[3] !== KTX2_ID[3] || id[4] !== KTX2_ID[4] || id[5] !== KTX2_ID[5] || id[6] !== KTX2_ID[6] || id[7] !== KTX2_ID[7] || id[8] !== KTX2_ID[8] || id[9] !== KTX2_ID[9] || id[10] !== KTX2_ID[10] || id[11] !== KTX2_ID[11];
-    return !notKTX;
+  // ../images/src/lib/parsers/svg-utils.ts
+  function isSVG(url) {
+    return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
   }
-  var KTX2_ID;
-  var init_parse_ktx = __esm({
-    "../textures/src/lib/parsers/parse-ktx.ts"() {
-      init_ktx_parse_modern();
-      KTX2_ID = [
-        171,
-        75,
-        84,
-        88,
-        32,
-        50,
-        48,
-        187,
-        13,
-        10,
-        26,
-        10
-      ];
-    }
-  });
-
-  // ../textures/src/lib/parsers/parse-basis.ts
-  async function parseBasis(data, options) {
-    if (options.basis.containerFormat === "auto") {
-      if (isKTX(data)) {
-        const fileConstructors = await loadBasisEncoderModule(options);
-        return parseKTX2File(fileConstructors.KTX2File, data, options);
+  function getBlobOrSVGDataUrl(arrayBuffer, url) {
+    if (isSVG(url)) {
+      const textDecoder = new TextDecoder();
+      let xmlText = textDecoder.decode(arrayBuffer);
+      try {
+        if (typeof unescape === "function" && typeof encodeURIComponent === "function") {
+          xmlText = unescape(encodeURIComponent(xmlText));
+        }
+      } catch (error) {
+        throw new Error(error.message);
       }
-      const { BasisFile } = await loadBasisTrascoderModule(options);
-      return parseBasisFile(BasisFile, data, options);
+      const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;
+      return src;
     }
-    switch (options.basis.module) {
-      case "encoder":
-        const fileConstructors = await loadBasisEncoderModule(options);
-        switch (options.basis.containerFormat) {
-          case "ktx2":
-            return parseKTX2File(fileConstructors.KTX2File, data, options);
-          case "basis":
-          default:
-            return parseBasisFile(fileConstructors.BasisFile, data, options);
-        }
-      case "transcoder":
-      default:
-        const { BasisFile } = await loadBasisTrascoderModule(options);
-        return parseBasisFile(BasisFile, data, options);
+    return getBlob(arrayBuffer, url);
+  }
+  function getBlob(arrayBuffer, url) {
+    if (isSVG(url)) {
+      throw new Error("SVG cannot be parsed directly to imagebitmap");
     }
+    return new Blob([new Uint8Array(arrayBuffer)]);
   }
-  function parseBasisFile(BasisFile, data, options) {
-    const basisFile = new BasisFile(new Uint8Array(data));
+  var SVG_DATA_URL_PATTERN, SVG_URL_PATTERN;
+  var init_svg_utils = __esm({
+    "../images/src/lib/parsers/svg-utils.ts"() {
+      SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
+      SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
+    }
+  });
+
+  // ../images/src/lib/parsers/parse-to-image.ts
+  async function parseToImage(arrayBuffer, options, url) {
+    const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
+    const URL = self.URL || self.webkitURL;
+    const objectUrl = typeof blobOrDataUrl !== "string" && URL.createObjectURL(blobOrDataUrl);
     try {
-      if (!basisFile.startTranscoding()) {
-        throw new Error("Failed to start basis transcoding");
-      }
-      const imageCount = basisFile.getNumImages();
-      const images = [];
-      for (let imageIndex = 0; imageIndex < imageCount; imageIndex++) {
-        const levelsCount = basisFile.getNumLevels(imageIndex);
-        const levels = [];
-        for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
-          levels.push(transcodeImage(basisFile, imageIndex, levelIndex, options));
-        }
-        images.push(levels);
-      }
-      return images;
+      return await loadToImage(objectUrl || blobOrDataUrl, options);
     } finally {
-      basisFile.close();
-      basisFile.delete();
+      if (objectUrl) {
+        URL.revokeObjectURL(objectUrl);
+      }
     }
   }
-  function transcodeImage(basisFile, imageIndex, levelIndex, options) {
-    const width = basisFile.getImageWidth(imageIndex, levelIndex);
-    const height = basisFile.getImageHeight(imageIndex, levelIndex);
-    const hasAlpha = basisFile.getHasAlpha();
-    const { compressed, format, basisFormat } = getBasisOptions(options, hasAlpha);
-    const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
-    const decodedData = new Uint8Array(decodedSize);
-    if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
-      throw new Error("failed to start Basis transcoding");
+  async function loadToImage(url, options) {
+    const image = new Image();
+    image.src = url;
+    if (options.image && options.image.decode && image.decode) {
+      await image.decode();
+      return image;
     }
-    return {
-      width,
-      height,
-      data: decodedData,
-      compressed,
-      format,
-      hasAlpha
-    };
-  }
-  function parseKTX2File(KTX2File, data, options) {
-    const ktx2File = new KTX2File(new Uint8Array(data));
-    try {
-      if (!ktx2File.startTranscoding()) {
-        throw new Error("failed to start KTX2 transcoding");
+    return await new Promise((resolve, reject) => {
+      try {
+        image.onload = () => resolve(image);
+        image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));
+      } catch (error) {
+        reject(error);
       }
-      const levelsCount = ktx2File.getLevels();
-      const levels = [];
-      for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
-        levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
-        break;
+    });
+  }
+  var init_parse_to_image = __esm({
+    "../images/src/lib/parsers/parse-to-image.ts"() {
+      init_svg_utils();
+    }
+  });
+
+  // ../images/src/lib/parsers/parse-to-image-bitmap.ts
+  async function parseToImageBitmap(arrayBuffer, options, url) {
+    let blob;
+    if (isSVG(url)) {
+      const image = await parseToImage(arrayBuffer, options, url);
+      blob = image;
+    } else {
+      blob = getBlob(arrayBuffer, url);
+    }
+    const imagebitmapOptions = options && options.imagebitmap;
+    return await safeCreateImageBitmap(blob, imagebitmapOptions);
+  }
+  async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
+    if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
+      imagebitmapOptions = null;
+    }
+    if (imagebitmapOptions) {
+      try {
+        return await createImageBitmap(blob, imagebitmapOptions);
+      } catch (error) {
+        console.warn(error);
+        imagebitmapOptionsSupported = false;
       }
-      return [levels];
-    } finally {
-      ktx2File.close();
-      ktx2File.delete();
     }
+    return await createImageBitmap(blob);
   }
-  function transcodeKTX2Image(ktx2File, levelIndex, options) {
-    const { alphaFlag, height, width } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
-    const { compressed, format, basisFormat } = getBasisOptions(options, alphaFlag);
-    const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0, 0, basisFormat);
-    const decodedData = new Uint8Array(decodedSize);
-    if (!ktx2File.transcodeImage(decodedData, levelIndex, 0, 0, basisFormat, 0, -1, -1)) {
-      throw new Error("Failed to transcode KTX2 image");
+  function isEmptyObject(object) {
+    for (const key in object || EMPTY_OBJECT) {
+      return false;
     }
-    return {
-      width,
-      height,
-      data: decodedData,
-      compressed,
-      levelSize: decodedSize,
-      hasAlpha: alphaFlag,
-      format
-    };
+    return true;
   }
-  function getBasisOptions(options, hasAlpha) {
-    let format = options && options.basis && options.basis.format;
-    if (format === "auto") {
-      format = selectSupportedBasisFormat();
+  var EMPTY_OBJECT, imagebitmapOptionsSupported;
+  var init_parse_to_image_bitmap = __esm({
+    "../images/src/lib/parsers/parse-to-image-bitmap.ts"() {
+      init_svg_utils();
+      init_parse_to_image();
+      EMPTY_OBJECT = {};
+      imagebitmapOptionsSupported = true;
     }
-    if (typeof format === "object") {
-      format = hasAlpha ? format.alpha : format.noAlpha;
+  });
+
+  // ../images/src/lib/category-api/parse-isobmff-binary.ts
+  function getISOBMFFMediaType(buffer) {
+    if (!checkString(buffer, "ftyp", 4)) {
+      return null;
     }
-    format = format.toLowerCase();
-    return OutputFormat[format];
+    if ((buffer[8] & 96) === 0) {
+      return null;
+    }
+    return decodeMajorBrand(buffer);
   }
-  function selectSupportedBasisFormat() {
-    const supportedFormats = getSupportedGPUTextureFormats();
-    if (supportedFormats.has("astc")) {
-      return "astc-4x4";
-    } else if (supportedFormats.has("dxt")) {
-      return {
-        alpha: "bc3",
-        noAlpha: "bc1"
-      };
-    } else if (supportedFormats.has("pvrtc")) {
-      return {
-        alpha: "pvrtc1-4-rgba",
-        noAlpha: "pvrtc1-4-rgb"
-      };
-    } else if (supportedFormats.has("etc1")) {
-      return "etc1";
-    } else if (supportedFormats.has("etc2")) {
-      return "etc2";
+  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;
     }
-    return "rgb565";
   }
-  var OutputFormat;
-  var init_parse_basis = __esm({
-    "../textures/src/lib/parsers/parse-basis.ts"() {
-      init_basis_module_loader();
-      init_gl_extensions();
-      init_texture_formats();
-      init_parse_ktx();
-      OutputFormat = {
-        etc1: {
-          basisFormat: 0,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
-        },
-        etc2: { basisFormat: 1, compressed: true },
-        bc1: {
-          basisFormat: 2,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
-        },
-        bc3: {
-          basisFormat: 3,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT
-        },
-        bc4: { basisFormat: 4, compressed: true },
-        bc5: { basisFormat: 5, compressed: true },
-        "bc7-m6-opaque-only": { basisFormat: 6, compressed: true },
-        "bc7-m5": { basisFormat: 7, compressed: true },
-        "pvrtc1-4-rgb": {
-          basisFormat: 8,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
-        },
-        "pvrtc1-4-rgba": {
-          basisFormat: 9,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
-        },
-        "astc-4x4": {
-          basisFormat: 10,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR
-        },
-        "atc-rgb": { basisFormat: 11, compressed: true },
-        "atc-rgba-interpolated-alpha": { basisFormat: 12, compressed: true },
-        rgba32: { basisFormat: 13, compressed: false },
-        rgb565: { basisFormat: 14, compressed: false },
-        bgr565: { basisFormat: 15, compressed: false },
-        rgba4444: { basisFormat: 16, compressed: false }
-      };
-    }
-  });
-
-  // ../textures/src/basis-loader.ts
-  var BasisWorkerLoader, BasisLoader;
-  var init_basis_loader = __esm({
-    "../textures/src/basis-loader.ts"() {
-      init_src();
-      init_version3();
-      init_parse_basis();
-      BasisWorkerLoader = {
-        name: "Basis",
-        id: isBrowser2 ? "basis" : "basis-nodejs",
-        module: "textures",
-        version: VERSION4,
-        worker: true,
-        extensions: ["basis", "ktx2"],
-        mimeTypes: ["application/octet-stream", "image/ktx2"],
-        tests: ["sB"],
-        binary: true,
-        options: {
-          basis: {
-            format: "auto",
-            libraryPath: "libs/",
-            containerFormat: "auto",
-            module: "transcoder"
-          }
-        }
-      };
-      BasisLoader = {
-        ...BasisWorkerLoader,
-        parse: parseBasis
-      };
-    }
-  });
-
-  // ../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 getUTF8String(array, start, end) {
+    return String.fromCharCode(...array.slice(start, end));
   }
-  function getDefaultImageType() {
-    if (IMAGE_BITMAP_SUPPORTED) {
-      return "imagebitmap";
-    }
-    if (IMAGE_SUPPORTED) {
-      return "image";
-    }
-    if (DATA_SUPPORTED) {
-      return "data";
+  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;
+      }
     }
-    throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js");
+    return true;
   }
-  var _parseImageNode, IMAGE_SUPPORTED, IMAGE_BITMAP_SUPPORTED, NODE_IMAGE_SUPPORTED, DATA_SUPPORTED;
-  var init_image_type = __esm({
-    "../images/src/lib/category-api/image-type.ts"() {
-      init_src2();
-      ({ _parseImageNode } = globalThis);
-      IMAGE_SUPPORTED = typeof Image !== "undefined";
-      IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
-      NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);
-      DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;
+  var init_parse_isobmff_binary = __esm({
+    "../images/src/lib/category-api/parse-isobmff-binary.ts"() {
     }
   });
 
-  // ../images/src/lib/category-api/parsed-image-api.ts
-  function getImageType(image) {
-    const format = getImageTypeOrNull(image);
-    if (!format) {
-      throw new Error("Not an image");
-    }
-    return format;
+  // ../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) || getISOBMFFMetadata(dataView);
   }
-  function getImageData(image) {
-    switch (getImageType(image)) {
-      case "data":
-        return image;
-      case "image":
-      case "imagebitmap":
-        const canvas = document.createElement("canvas");
-        const context = canvas.getContext("2d");
-        if (!context) {
-          throw new Error("getImageData");
-        }
-        canvas.width = image.width;
-        canvas.height = image.height;
-        context.drawImage(image, 0, 0);
-        return context.getImageData(0, 0, image.width, image.height);
-      default:
-        throw new Error("getImageData");
+  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 getImageTypeOrNull(image) {
-    if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
-      return "imagebitmap";
-    }
-    if (typeof Image !== "undefined" && image instanceof Image) {
-      return "image";
+  function getPngMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511;
+    if (!isPng) {
+      return null;
     }
-    if (image && typeof image === "object" && image.data && image.width && image.height) {
-      return "data";
+    return {
+      mimeType: "image/png",
+      width: dataView.getUint32(16, BIG_ENDIAN),
+      height: dataView.getUint32(20, BIG_ENDIAN)
+    };
+  }
+  function getGifMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440;
+    if (!isGif) {
+      return null;
     }
-    return null;
+    return {
+      mimeType: "image/gif",
+      width: dataView.getUint16(6, LITTLE_ENDIAN),
+      height: dataView.getUint16(8, LITTLE_ENDIAN)
+    };
   }
-  var init_parsed_image_api = __esm({
-    "../images/src/lib/category-api/parsed-image-api.ts"() {
+  function getBmpMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 16973 && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;
+    if (!isBmp) {
+      return null;
     }
-  });
-
-  // ../images/src/lib/parsers/svg-utils.ts
-  function isSVG(url) {
-    return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
+    return {
+      mimeType: "image/bmp",
+      width: dataView.getUint32(18, LITTLE_ENDIAN),
+      height: dataView.getUint32(22, LITTLE_ENDIAN)
+    };
   }
-  function getBlobOrSVGDataUrl(arrayBuffer, url) {
-    if (isSVG(url)) {
-      const textDecoder = new TextDecoder();
-      let xmlText = textDecoder.decode(arrayBuffer);
-      try {
-        if (typeof unescape === "function" && typeof encodeURIComponent === "function") {
-          xmlText = unescape(encodeURIComponent(xmlText));
-        }
-      } catch (error) {
-        throw new Error(error.message);
+  function getJpegMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 65496 && dataView.getUint8(2) === 255;
+    if (!isJpeg) {
+      return null;
+    }
+    const { tableMarkers, sofMarkers } = getJpegMarkers();
+    let i2 = 2;
+    while (i2 + 9 < dataView.byteLength) {
+      const marker = dataView.getUint16(i2, BIG_ENDIAN);
+      if (sofMarkers.has(marker)) {
+        return {
+          mimeType: "image/jpeg",
+          height: dataView.getUint16(i2 + 5, BIG_ENDIAN),
+          width: dataView.getUint16(i2 + 7, BIG_ENDIAN)
+        };
       }
-      const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;
-      return src;
+      if (!tableMarkers.has(marker)) {
+        return null;
+      }
+      i2 += 2;
+      i2 += dataView.getUint16(i2, BIG_ENDIAN);
     }
-    return getBlob(arrayBuffer, url);
-  }
-  function getBlob(arrayBuffer, url) {
-    if (isSVG(url)) {
-      throw new Error("SVG cannot be parsed directly to imagebitmap");
-    }
-    return new Blob([new Uint8Array(arrayBuffer)]);
-  }
-  var SVG_DATA_URL_PATTERN, SVG_URL_PATTERN;
-  var init_svg_utils = __esm({
-    "../images/src/lib/parsers/svg-utils.ts"() {
-      SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
-      SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
-    }
-  });
-
-  // ../images/src/lib/parsers/parse-to-image.ts
-  async function parseToImage(arrayBuffer, options, url) {
-    const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
-    const URL = self.URL || self.webkitURL;
-    const objectUrl = typeof blobOrDataUrl !== "string" && URL.createObjectURL(blobOrDataUrl);
-    try {
-      return await loadToImage(objectUrl || blobOrDataUrl, options);
-    } finally {
-      if (objectUrl) {
-        URL.revokeObjectURL(objectUrl);
-      }
-    }
-  }
-  async function loadToImage(url, options) {
-    const image = new Image();
-    image.src = url;
-    if (options.image && options.image.decode && image.decode) {
-      await image.decode();
-      return image;
-    }
-    return await new Promise((resolve, reject) => {
-      try {
-        image.onload = () => resolve(image);
-        image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-  var init_parse_to_image = __esm({
-    "../images/src/lib/parsers/parse-to-image.ts"() {
-      init_svg_utils();
-    }
-  });
-
-  // ../images/src/lib/parsers/parse-to-image-bitmap.ts
-  async function parseToImageBitmap(arrayBuffer, options, url) {
-    let blob;
-    if (isSVG(url)) {
-      const image = await parseToImage(arrayBuffer, options, url);
-      blob = image;
-    } else {
-      blob = getBlob(arrayBuffer, url);
-    }
-    const imagebitmapOptions = options && options.imagebitmap;
-    return await safeCreateImageBitmap(blob, imagebitmapOptions);
-  }
-  async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
-    if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
-      imagebitmapOptions = null;
-    }
-    if (imagebitmapOptions) {
-      try {
-        return await createImageBitmap(blob, imagebitmapOptions);
-      } catch (error) {
-        console.warn(error);
-        imagebitmapOptionsSupported = false;
-      }
-    }
-    return await createImageBitmap(blob);
-  }
-  function isEmptyObject(object) {
-    for (const key in object || EMPTY_OBJECT) {
-      return false;
-    }
-    return true;
-  }
-  var EMPTY_OBJECT, imagebitmapOptionsSupported;
-  var init_parse_to_image_bitmap = __esm({
-    "../images/src/lib/parsers/parse-to-image-bitmap.ts"() {
-      init_svg_utils();
-      init_parse_to_image();
-      EMPTY_OBJECT = {};
-      imagebitmapOptionsSupported = true;
-    }
-  });
-
-  // ../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) || 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);
-    const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511;
-    if (!isPng) {
-      return null;
-    }
-    return {
-      mimeType: "image/png",
-      width: dataView.getUint32(16, BIG_ENDIAN),
-      height: dataView.getUint32(20, BIG_ENDIAN)
-    };
-  }
-  function getGifMetadata(binaryData) {
-    const dataView = toDataView(binaryData);
-    const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440;
-    if (!isGif) {
-      return null;
-    }
-    return {
-      mimeType: "image/gif",
-      width: dataView.getUint16(6, LITTLE_ENDIAN),
-      height: dataView.getUint16(8, LITTLE_ENDIAN)
-    };
-  }
-  function getBmpMetadata(binaryData) {
-    const dataView = toDataView(binaryData);
-    const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 16973 && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;
-    if (!isBmp) {
-      return null;
-    }
-    return {
-      mimeType: "image/bmp",
-      width: dataView.getUint32(18, LITTLE_ENDIAN),
-      height: dataView.getUint32(22, LITTLE_ENDIAN)
-    };
-  }
-  function getJpegMetadata(binaryData) {
-    const dataView = toDataView(binaryData);
-    const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 65496 && dataView.getUint8(2) === 255;
-    if (!isJpeg) {
-      return null;
-    }
-    const { tableMarkers, sofMarkers } = getJpegMarkers();
-    let i2 = 2;
-    while (i2 + 9 < dataView.byteLength) {
-      const marker = dataView.getUint16(i2, BIG_ENDIAN);
-      if (sofMarkers.has(marker)) {
-        return {
-          mimeType: "image/jpeg",
-          height: dataView.getUint16(i2 + 5, BIG_ENDIAN),
-          width: dataView.getUint16(i2 + 7, BIG_ENDIAN)
-        };
-      }
-      if (!tableMarkers.has(marker)) {
-        return null;
-      }
-      i2 += 2;
-      i2 += dataView.getUint16(i2, BIG_ENDIAN);
-    }
-    return null;
+    return null;
   }
   function getJpegMarkers() {
     const tableMarkers = new Set([65499, 65476, 65484, 65501, 65534]);
@@ -1148,150 +684,613 @@
     }
   });
 
-  // ../images/src/lib/parsers/parse-to-node-image.ts
-  async function parseToNodeImage(arrayBuffer, options) {
-    const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
-    const _parseImageNode2 = globalThis._parseImageNode;
-    assert(_parseImageNode2);
-    return await _parseImageNode2(arrayBuffer, mimeType);
+  // ../images/src/lib/parsers/parse-to-node-image.ts
+  async function parseToNodeImage(arrayBuffer, options) {
+    const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
+    const _parseImageNode2 = globalThis._parseImageNode;
+    assert(_parseImageNode2);
+    return await _parseImageNode2(arrayBuffer, mimeType);
+  }
+  var init_parse_to_node_image = __esm({
+    "../images/src/lib/parsers/parse-to-node-image.ts"() {
+      init_src2();
+      init_binary_image_api();
+    }
+  });
+
+  // ../images/src/lib/parsers/parse-image.ts
+  async function parseImage(arrayBuffer, options, context) {
+    options = options || {};
+    const imageOptions = options.image || {};
+    const imageType = imageOptions.type || "auto";
+    const { url } = context || {};
+    const loadType = getLoadableImageType(imageType);
+    let image;
+    switch (loadType) {
+      case "imagebitmap":
+        image = await parseToImageBitmap(arrayBuffer, options, url);
+        break;
+      case "image":
+        image = await parseToImage(arrayBuffer, options, url);
+        break;
+      case "data":
+        image = await parseToNodeImage(arrayBuffer, options);
+        break;
+      default:
+        assert(false);
+    }
+    if (imageType === "data") {
+      image = getImageData(image);
+    }
+    return image;
+  }
+  function getLoadableImageType(type) {
+    switch (type) {
+      case "auto":
+      case "data":
+        return getDefaultImageType();
+      default:
+        isImageTypeSupported(type);
+        return type;
+    }
+  }
+  var init_parse_image = __esm({
+    "../images/src/lib/parsers/parse-image.ts"() {
+      init_src2();
+      init_image_type();
+      init_parsed_image_api();
+      init_parse_to_image();
+      init_parse_to_image_bitmap();
+      init_parse_to_node_image();
+    }
+  });
+
+  // ../images/src/image-loader.ts
+  var EXTENSIONS, MIME_TYPES, DEFAULT_IMAGE_LOADER_OPTIONS, ImageLoader;
+  var init_image_loader = __esm({
+    "../images/src/image-loader.ts"() {
+      init_version3();
+      init_parse_image();
+      init_binary_image_api();
+      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"
+      ];
+      DEFAULT_IMAGE_LOADER_OPTIONS = {
+        image: {
+          type: "auto",
+          decode: true
+        }
+      };
+      ImageLoader = {
+        id: "image",
+        module: "images",
+        name: "Images",
+        version: VERSION4,
+        mimeTypes: MIME_TYPES,
+        extensions: EXTENSIONS,
+        parse: parseImage,
+        tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
+        options: DEFAULT_IMAGE_LOADER_OPTIONS
+      };
+    }
+  });
+
+  // ../images/src/lib/category-api/image-format.ts
+  function isImageFormatSupported(mimeType) {
+    if (mimeTypeSupportedSync[mimeType] === void 0) {
+      const supported = isBrowser ? checkBrowserImageFormatSupport(mimeType) : checkNodeImageFormatSupport(mimeType);
+      mimeTypeSupportedSync[mimeType] = supported;
+    }
+    return mimeTypeSupportedSync[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 testBrowserImageFormatSupport(mimeType);
+      default:
+        return true;
+    }
+  }
+  function testBrowserImageFormatSupport(mimeType) {
+    try {
+      const element = document.createElement("canvas");
+      const dataURL = element.toDataURL(mimeType);
+      return dataURL.indexOf(`data:${mimeType}`) === 0;
+    } catch {
+      return false;
+    }
+  }
+  var mimeTypeSupportedSync;
+  var init_image_format = __esm({
+    "../images/src/lib/category-api/image-format.ts"() {
+      init_src2();
+      mimeTypeSupportedSync = {};
+    }
+  });
+
+  // ../images/src/index.ts
+  var init_src3 = __esm({
+    "../images/src/index.ts"() {
+      init_image_loader();
+      init_binary_image_api();
+      init_parsed_image_api();
+      init_image_format();
+    }
+  });
+
+  // ../textures/src/lib/utils/version.ts
+  var VERSION5;
+  var init_version4 = __esm({
+    "../textures/src/lib/utils/version.ts"() {
+      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+    }
+  });
+
+  // ../textures/src/lib/parsers/basis-module-loader.ts
+  async function loadBasisTrascoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basis) {
+      return modules.basis;
+    }
+    loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTrascoder(options);
+    return await loadBasisTranscoderPromise;
+  }
+  async function loadBasisTrascoder(options) {
+    let BASIS = null;
+    let wasmBinary = null;
+    [BASIS, wasmBinary] = await Promise.all([
+      await loadLibrary("basis_transcoder.js", "textures", options),
+      await loadLibrary("basis_transcoder.wasm", "textures", options)
+    ]);
+    BASIS = BASIS || globalThis.BASIS;
+    return await initializeBasisTrascoderModule(BASIS, wasmBinary);
+  }
+  function initializeBasisTrascoderModule(BasisModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve) => {
+      BasisModule(options).then((module) => {
+        const { BasisFile, initializeBasis } = module;
+        initializeBasis();
+        resolve({ BasisFile });
+      });
+    });
+  }
+  async function loadBasisEncoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basisEncoder) {
+      return modules.basisEncoder;
+    }
+    loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
+    return await loadBasisEncoderPromise;
+  }
+  async function loadBasisEncoder(options) {
+    let BASIS_ENCODER = null;
+    let wasmBinary = null;
+    [BASIS_ENCODER, wasmBinary] = await Promise.all([
+      await loadLibrary(BASIS_CDN_ENCODER_JS, "textures", options),
+      await loadLibrary(BASIS_CDN_ENCODER_WASM, "textures", options)
+    ]);
+    BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
+    return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
+  }
+  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve) => {
+      BasisEncoderModule(options).then((module) => {
+        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
+        initializeBasis();
+        resolve({ BasisFile, KTX2File, BasisEncoder });
+      });
+    });
+  }
+  var VERSION6, BASIS_CDN_ENCODER_WASM, BASIS_CDN_ENCODER_JS, loadBasisTranscoderPromise, loadBasisEncoderPromise;
+  var init_basis_module_loader = __esm({
+    "../textures/src/lib/parsers/basis-module-loader.ts"() {
+      init_src();
+      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION6}/dist/libs/basis_encoder.wasm`;
+      BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION6}/dist/libs/basis_encoder.js`;
+    }
+  });
+
+  // ../textures/src/lib/gl-extensions.ts
+  var GL_EXTENSIONS_CONSTANTS;
+  var init_gl_extensions = __esm({
+    "../textures/src/lib/gl-extensions.ts"() {
+      GL_EXTENSIONS_CONSTANTS = {
+        COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
+        COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
+        COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
+        COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
+        COMPRESSED_R11_EAC: 37488,
+        COMPRESSED_SIGNED_R11_EAC: 37489,
+        COMPRESSED_RG11_EAC: 37490,
+        COMPRESSED_SIGNED_RG11_EAC: 37491,
+        COMPRESSED_RGB8_ETC2: 37492,
+        COMPRESSED_RGBA8_ETC2_EAC: 37493,
+        COMPRESSED_SRGB8_ETC2: 37494,
+        COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37495,
+        COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37496,
+        COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37497,
+        COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
+        COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
+        COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
+        COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
+        COMPRESSED_RGB_ETC1_WEBGL: 36196,
+        COMPRESSED_RGB_ATC_WEBGL: 35986,
+        COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35987,
+        COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798,
+        COMPRESSED_RGBA_ASTC_4X4_KHR: 37808,
+        COMPRESSED_RGBA_ASTC_5X4_KHR: 37809,
+        COMPRESSED_RGBA_ASTC_5X5_KHR: 37810,
+        COMPRESSED_RGBA_ASTC_6X5_KHR: 37811,
+        COMPRESSED_RGBA_ASTC_6X6_KHR: 37812,
+        COMPRESSED_RGBA_ASTC_8X5_KHR: 37813,
+        COMPRESSED_RGBA_ASTC_8X6_KHR: 37814,
+        COMPRESSED_RGBA_ASTC_8X8_KHR: 37815,
+        COMPRESSED_RGBA_ASTC_10X5_KHR: 37816,
+        COMPRESSED_RGBA_ASTC_10X6_KHR: 37817,
+        COMPRESSED_RGBA_ASTC_10X8_KHR: 37818,
+        COMPRESSED_RGBA_ASTC_10X10_KHR: 37819,
+        COMPRESSED_RGBA_ASTC_12X10_KHR: 37820,
+        COMPRESSED_RGBA_ASTC_12X12_KHR: 37821,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR: 37840,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR: 37841,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR: 37842,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR: 37843,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR: 37844,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR: 37845,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR: 37846,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR: 37847,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR: 37848,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR: 37849,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR: 37850,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR: 37851,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR: 37852,
+        COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR: 37853,
+        COMPRESSED_RED_RGTC1_EXT: 36283,
+        COMPRESSED_SIGNED_RED_RGTC1_EXT: 36284,
+        COMPRESSED_RED_GREEN_RGTC2_EXT: 36285,
+        COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 36286,
+        COMPRESSED_SRGB_S3TC_DXT1_EXT: 35916,
+        COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 35917,
+        COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 35918,
+        COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 35919
+      };
+    }
+  });
+
+  // ../textures/src/lib/utils/texture-formats.ts
+  function getSupportedGPUTextureFormats(gl) {
+    if (!formats) {
+      gl = gl || getWebGLContext() || void 0;
+      formats = new Set();
+      for (const prefix of BROWSER_PREFIXES) {
+        for (const extension in WEBGL_EXTENSIONS) {
+          if (gl && gl.getExtension(`${prefix}${extension}`)) {
+            const gpuTextureFormat = WEBGL_EXTENSIONS[extension];
+            formats.add(gpuTextureFormat);
+          }
+        }
+      }
+    }
+    return formats;
+  }
+  function getWebGLContext() {
+    try {
+      const canvas = document.createElement("canvas");
+      return canvas.getContext("webgl");
+    } catch (error) {
+      return null;
+    }
+  }
+  var BROWSER_PREFIXES, WEBGL_EXTENSIONS, formats;
+  var init_texture_formats = __esm({
+    "../textures/src/lib/utils/texture-formats.ts"() {
+      BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
+      WEBGL_EXTENSIONS = {
+        WEBGL_compressed_texture_s3tc: "dxt",
+        WEBGL_compressed_texture_s3tc_srgb: "dxt-srgb",
+        WEBGL_compressed_texture_etc1: "etc1",
+        WEBGL_compressed_texture_etc: "etc2",
+        WEBGL_compressed_texture_pvrtc: "pvrtc",
+        WEBGL_compressed_texture_atc: "atc",
+        WEBGL_compressed_texture_astc: "astc",
+        EXT_texture_compression_rgtc: "rgtc"
+      };
+      formats = null;
+    }
+  });
+
+  // ../../node_modules/ktx-parse/dist/ktx-parse.modern.js
+  var t, n, i, s, a, r, o, l, f;
+  var init_ktx_parse_modern = __esm({
+    "../../node_modules/ktx-parse/dist/ktx-parse.modern.js"() {
+      t = new Uint8Array([0]);
+      !function(t2) {
+        t2[t2.NONE = 0] = "NONE", t2[t2.BASISLZ = 1] = "BASISLZ", t2[t2.ZSTD = 2] = "ZSTD", t2[t2.ZLIB = 3] = "ZLIB";
+      }(n || (n = {})), function(t2) {
+        t2[t2.BASICFORMAT = 0] = "BASICFORMAT";
+      }(i || (i = {})), function(t2) {
+        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.ETC1S = 163] = "ETC1S", t2[t2.UASTC = 166] = "UASTC";
+      }(s || (s = {})), function(t2) {
+        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.SRGB = 1] = "SRGB";
+      }(a || (a = {})), function(t2) {
+        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.LINEAR = 1] = "LINEAR", t2[t2.SRGB = 2] = "SRGB", t2[t2.ITU = 3] = "ITU", t2[t2.NTSC = 4] = "NTSC", t2[t2.SLOG = 5] = "SLOG", t2[t2.SLOG2 = 6] = "SLOG2";
+      }(r || (r = {})), function(t2) {
+        t2[t2.ALPHA_STRAIGHT = 0] = "ALPHA_STRAIGHT", t2[t2.ALPHA_PREMULTIPLIED = 1] = "ALPHA_PREMULTIPLIED";
+      }(o || (o = {})), function(t2) {
+        t2[t2.RGB = 0] = "RGB", t2[t2.RRR = 3] = "RRR", t2[t2.GGG = 4] = "GGG", t2[t2.AAA = 15] = "AAA";
+      }(l || (l = {})), function(t2) {
+        t2[t2.RGB = 0] = "RGB", t2[t2.RGBA = 3] = "RGBA", t2[t2.RRR = 4] = "RRR", t2[t2.RRRG = 5] = "RRRG";
+      }(f || (f = {}));
+    }
+  });
+
+  // ../textures/src/lib/parsers/parse-ktx.ts
+  function isKTX(data) {
+    const id = new Uint8Array(data);
+    const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || id[1] !== KTX2_ID[1] || id[2] !== KTX2_ID[2] || id[3] !== KTX2_ID[3] || id[4] !== KTX2_ID[4] || id[5] !== KTX2_ID[5] || id[6] !== KTX2_ID[6] || id[7] !== KTX2_ID[7] || id[8] !== KTX2_ID[8] || id[9] !== KTX2_ID[9] || id[10] !== KTX2_ID[10] || id[11] !== KTX2_ID[11];
+    return !notKTX;
   }
-  var init_parse_to_node_image = __esm({
-    "../images/src/lib/parsers/parse-to-node-image.ts"() {
-      init_src2();
-      init_binary_image_api();
+  var KTX2_ID;
+  var init_parse_ktx = __esm({
+    "../textures/src/lib/parsers/parse-ktx.ts"() {
+      init_ktx_parse_modern();
+      KTX2_ID = [
+        171,
+        75,
+        84,
+        88,
+        32,
+        50,
+        48,
+        187,
+        13,
+        10,
+        26,
+        10
+      ];
     }
   });
 
-  // ../images/src/lib/parsers/parse-image.ts
-  async function parseImage(arrayBuffer, options, context) {
-    options = options || {};
-    const imageOptions = options.image || {};
-    const imageType = imageOptions.type || "auto";
-    const { url } = context || {};
-    const loadType = getLoadableImageType(imageType);
-    let image;
-    switch (loadType) {
-      case "imagebitmap":
-        image = await parseToImageBitmap(arrayBuffer, options, url);
-        break;
-      case "image":
-        image = await parseToImage(arrayBuffer, options, url);
-        break;
-      case "data":
-        image = await parseToNodeImage(arrayBuffer, options);
-        break;
-      default:
-        assert(false);
-    }
-    if (imageType === "data") {
-      image = getImageData(image);
+  // ../textures/src/lib/parsers/parse-basis.ts
+  async function parseBasis(data, options) {
+    if (options.basis.containerFormat === "auto") {
+      if (isKTX(data)) {
+        const fileConstructors = await loadBasisEncoderModule(options);
+        return parseKTX2File(fileConstructors.KTX2File, data, options);
+      }
+      const { BasisFile } = await loadBasisTrascoderModule(options);
+      return parseBasisFile(BasisFile, data, options);
     }
-    return image;
-  }
-  function getLoadableImageType(type) {
-    switch (type) {
-      case "auto":
-      case "data":
-        return getDefaultImageType();
+    switch (options.basis.module) {
+      case "encoder":
+        const fileConstructors = await loadBasisEncoderModule(options);
+        switch (options.basis.containerFormat) {
+          case "ktx2":
+            return parseKTX2File(fileConstructors.KTX2File, data, options);
+          case "basis":
+          default:
+            return parseBasisFile(fileConstructors.BasisFile, data, options);
+        }
+      case "transcoder":
       default:
-        isImageTypeSupported(type);
-        return type;
+        const { BasisFile } = await loadBasisTrascoderModule(options);
+        return parseBasisFile(BasisFile, data, options);
     }
   }
-  var init_parse_image = __esm({
-    "../images/src/lib/parsers/parse-image.ts"() {
-      init_src2();
-      init_image_type();
-      init_parsed_image_api();
-      init_parse_to_image();
-      init_parse_to_image_bitmap();
-      init_parse_to_node_image();
-    }
-  });
-
-  // ../images/src/image-loader.ts
-  var EXTENSIONS, MIME_TYPES, DEFAULT_IMAGE_LOADER_OPTIONS, ImageLoader;
-  var init_image_loader = __esm({
-    "../images/src/image-loader.ts"() {
-      init_version4();
-      init_parse_image();
-      init_binary_image_api();
-      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"
-      ];
-      DEFAULT_IMAGE_LOADER_OPTIONS = {
-        image: {
-          type: "auto",
-          decode: true
+  function parseBasisFile(BasisFile, data, options) {
+    const basisFile = new BasisFile(new Uint8Array(data));
+    try {
+      if (!basisFile.startTranscoding()) {
+        throw new Error("Failed to start basis transcoding");
+      }
+      const imageCount = basisFile.getNumImages();
+      const images = [];
+      for (let imageIndex = 0; imageIndex < imageCount; imageIndex++) {
+        const levelsCount = basisFile.getNumLevels(imageIndex);
+        const levels = [];
+        for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
+          levels.push(transcodeImage(basisFile, imageIndex, levelIndex, options));
         }
-      };
-      ImageLoader = {
-        id: "image",
-        module: "images",
-        name: "Images",
-        version: VERSION6,
-        mimeTypes: MIME_TYPES,
-        extensions: EXTENSIONS,
-        parse: parseImage,
-        tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
-        options: DEFAULT_IMAGE_LOADER_OPTIONS
-      };
+        images.push(levels);
+      }
+      return images;
+    } finally {
+      basisFile.close();
+      basisFile.delete();
     }
-  });
-
-  // ../images/src/lib/category-api/image-format.ts
-  function isImageFormatSupported(mimeType) {
-    if (mimeTypeSupportedSync[mimeType] === void 0) {
-      const supported = isBrowser ? checkBrowserImageFormatSupport(mimeType) : checkNodeImageFormatSupport(mimeType);
-      mimeTypeSupportedSync[mimeType] = supported;
+  }
+  function transcodeImage(basisFile, imageIndex, levelIndex, options) {
+    const width = basisFile.getImageWidth(imageIndex, levelIndex);
+    const height = basisFile.getImageHeight(imageIndex, levelIndex);
+    const hasAlpha = basisFile.getHasAlpha();
+    const { compressed, format, basisFormat } = getBasisOptions(options, hasAlpha);
+    const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
+    const decodedData = new Uint8Array(decodedSize);
+    if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
+      throw new Error("failed to start Basis transcoding");
     }
-    return mimeTypeSupportedSync[mimeType];
+    return {
+      width,
+      height,
+      data: decodedData,
+      compressed,
+      format,
+      hasAlpha
+    };
   }
-  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 parseKTX2File(KTX2File, data, options) {
+    const ktx2File = new KTX2File(new Uint8Array(data));
+    try {
+      if (!ktx2File.startTranscoding()) {
+        throw new Error("failed to start KTX2 transcoding");
+      }
+      const levelsCount = ktx2File.getLevels();
+      const levels = [];
+      for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
+        levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
+        break;
+      }
+      return [levels];
+    } finally {
+      ktx2File.close();
+      ktx2File.delete();
+    }
   }
-  function checkBrowserImageFormatSupport(mimeType) {
-    switch (mimeType) {
-      case "image/avif":
-      case "image/webp":
-        return testBrowserImageFormatSupport(mimeType);
-      default:
-        return true;
+  function transcodeKTX2Image(ktx2File, levelIndex, options) {
+    const { alphaFlag, height, width } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
+    const { compressed, format, basisFormat } = getBasisOptions(options, alphaFlag);
+    const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0, 0, basisFormat);
+    const decodedData = new Uint8Array(decodedSize);
+    if (!ktx2File.transcodeImage(decodedData, levelIndex, 0, 0, basisFormat, 0, -1, -1)) {
+      throw new Error("Failed to transcode KTX2 image");
     }
+    return {
+      width,
+      height,
+      data: decodedData,
+      compressed,
+      levelSize: decodedSize,
+      hasAlpha: alphaFlag,
+      format
+    };
   }
-  function testBrowserImageFormatSupport(mimeType) {
-    try {
-      const element = document.createElement("canvas");
-      const dataURL = element.toDataURL(mimeType);
-      return dataURL.indexOf(`data:${mimeType}`) === 0;
-    } catch {
-      return false;
+  function getBasisOptions(options, hasAlpha) {
+    let format = options && options.basis && options.basis.format;
+    if (format === "auto") {
+      format = selectSupportedBasisFormat();
+    }
+    if (typeof format === "object") {
+      format = hasAlpha ? format.alpha : format.noAlpha;
+    }
+    format = format.toLowerCase();
+    return OutputFormat[format];
+  }
+  function selectSupportedBasisFormat() {
+    const supportedFormats = getSupportedGPUTextureFormats();
+    if (supportedFormats.has("astc")) {
+      return "astc-4x4";
+    } else if (supportedFormats.has("dxt")) {
+      return {
+        alpha: "bc3",
+        noAlpha: "bc1"
+      };
+    } else if (supportedFormats.has("pvrtc")) {
+      return {
+        alpha: "pvrtc1-4-rgba",
+        noAlpha: "pvrtc1-4-rgb"
+      };
+    } else if (supportedFormats.has("etc1")) {
+      return "etc1";
+    } else if (supportedFormats.has("etc2")) {
+      return "etc2";
     }
+    return "rgb565";
   }
-  var mimeTypeSupportedSync;
-  var init_image_format = __esm({
-    "../images/src/lib/category-api/image-format.ts"() {
-      init_src2();
-      mimeTypeSupportedSync = {};
+  var OutputFormat;
+  var init_parse_basis = __esm({
+    "../textures/src/lib/parsers/parse-basis.ts"() {
+      init_basis_module_loader();
+      init_gl_extensions();
+      init_texture_formats();
+      init_parse_ktx();
+      OutputFormat = {
+        etc1: {
+          basisFormat: 0,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
+        },
+        etc2: { basisFormat: 1, compressed: true },
+        bc1: {
+          basisFormat: 2,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
+        },
+        bc3: {
+          basisFormat: 3,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT
+        },
+        bc4: { basisFormat: 4, compressed: true },
+        bc5: { basisFormat: 5, compressed: true },
+        "bc7-m6-opaque-only": { basisFormat: 6, compressed: true },
+        "bc7-m5": { basisFormat: 7, compressed: true },
+        "pvrtc1-4-rgb": {
+          basisFormat: 8,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
+        },
+        "pvrtc1-4-rgba": {
+          basisFormat: 9,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+        },
+        "astc-4x4": {
+          basisFormat: 10,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR
+        },
+        "atc-rgb": { basisFormat: 11, compressed: true },
+        "atc-rgba-interpolated-alpha": { basisFormat: 12, compressed: true },
+        rgba32: { basisFormat: 13, compressed: false },
+        rgb565: { basisFormat: 14, compressed: false },
+        bgr565: { basisFormat: 15, compressed: false },
+        rgba4444: { basisFormat: 16, compressed: false }
+      };
     }
   });
 
-  // ../images/src/index.ts
-  var init_src3 = __esm({
-    "../images/src/index.ts"() {
-      init_image_loader();
-      init_binary_image_api();
-      init_image_format();
+  // ../textures/src/basis-loader.ts
+  var BasisWorkerLoader, BasisLoader;
+  var init_basis_loader = __esm({
+    "../textures/src/basis-loader.ts"() {
+      init_version4();
+      init_parse_basis();
+      BasisWorkerLoader = {
+        name: "Basis",
+        id: "basis",
+        module: "textures",
+        version: VERSION5,
+        worker: true,
+        extensions: ["basis", "ktx2"],
+        mimeTypes: ["application/octet-stream", "image/ktx2"],
+        tests: ["sB"],
+        binary: true,
+        options: {
+          basis: {
+            format: "auto",
+            libraryPath: "libs/",
+            containerFormat: "auto",
+            module: "transcoder"
+          }
+        }
+      };
+      BasisLoader = {
+        ...BasisWorkerLoader,
+        parse: parseBasis
+      };
     }
   });
 
@@ -1314,6 +1313,119 @@
     }
   });
 
+  // src/lib/parsers/parse-glb.ts
+  function getMagicString2(dataView, byteOffset = 0) {
+    return `${String.fromCharCode(dataView.getUint8(byteOffset + 0))}${String.fromCharCode(dataView.getUint8(byteOffset + 1))}${String.fromCharCode(dataView.getUint8(byteOffset + 2))}${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;
+  }
+  function isGLB(arrayBuffer, byteOffset = 0, options = {}) {
+    const dataView = new DataView(arrayBuffer);
+    const { magic = MAGIC_glTF } = options;
+    const magic1 = dataView.getUint32(byteOffset, false);
+    return magic1 === magic || magic1 === MAGIC_glTF;
+  }
+  function parseGLBSync(glb, arrayBuffer, byteOffset = 0, options = {}) {
+    const dataView = new DataView(arrayBuffer);
+    const type = getMagicString2(dataView, byteOffset + 0);
+    const version = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
+    const byteLength = dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN2);
+    Object.assign(glb, {
+      header: {
+        byteOffset,
+        byteLength,
+        hasBinChunk: false
+      },
+      type,
+      version,
+      json: {},
+      binChunks: []
+    });
+    byteOffset += GLB_FILE_HEADER_SIZE;
+    switch (glb.version) {
+      case 1:
+        return parseGLBV1(glb, dataView, byteOffset);
+      case 2:
+        return parseGLBV2(glb, dataView, byteOffset, options = {});
+      default:
+        throw new Error(`Invalid GLB version ${glb.version}. Only supports version 1 and 2.`);
+    }
+  }
+  function parseGLBV1(glb, dataView, byteOffset) {
+    assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+    const contentLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN2);
+    const contentFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
+    byteOffset += GLB_CHUNK_HEADER_SIZE;
+    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) {
+    assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+    parseGLBChunksSync(glb, dataView, byteOffset, options);
+    return byteOffset + glb.header.byteLength;
+  }
+  function parseGLBChunksSync(glb, dataView, byteOffset, options) {
+    while (byteOffset + 8 <= glb.header.byteLength) {
+      const chunkLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN2);
+      const chunkFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
+      byteOffset += GLB_CHUNK_HEADER_SIZE;
+      switch (chunkFormat) {
+        case GLB_CHUNK_TYPE_JSON:
+          parseJSONChunk(glb, dataView, byteOffset, chunkLength);
+          break;
+        case GLB_CHUNK_TYPE_BIN:
+          parseBINChunk(glb, dataView, byteOffset, chunkLength);
+          break;
+        case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:
+          if (!options.strict) {
+            parseJSONChunk(glb, dataView, byteOffset, chunkLength);
+          }
+          break;
+        case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:
+          if (!options.strict) {
+            parseBINChunk(glb, dataView, byteOffset, chunkLength);
+          }
+          break;
+        default:
+          break;
+      }
+      byteOffset += padToNBytes(chunkLength, 4);
+    }
+    return byteOffset;
+  }
+  function parseJSONChunk(glb, dataView, byteOffset, chunkLength) {
+    const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);
+    const textDecoder = new TextDecoder("utf8");
+    const jsonText = textDecoder.decode(jsonChunk);
+    glb.json = JSON.parse(jsonText);
+    return padToNBytes(chunkLength, 4);
+  }
+  function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
+    glb.header.hasBinChunk = true;
+    glb.binChunks.push({
+      byteOffset,
+      byteLength: chunkLength,
+      arrayBuffer: dataView.buffer
+    });
+    return padToNBytes(chunkLength, 4);
+  }
+  var LITTLE_ENDIAN2, MAGIC_glTF, GLB_FILE_HEADER_SIZE, GLB_CHUNK_HEADER_SIZE, GLB_CHUNK_TYPE_JSON, GLB_CHUNK_TYPE_BIN, GLB_V1_CONTENT_FORMAT_JSON, GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED, GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED;
+  var init_parse_glb = __esm({
+    "src/lib/parsers/parse-glb.ts"() {
+      init_src2();
+      LITTLE_ENDIAN2 = true;
+      MAGIC_glTF = 1735152710;
+      GLB_FILE_HEADER_SIZE = 12;
+      GLB_CHUNK_HEADER_SIZE = 8;
+      GLB_CHUNK_TYPE_JSON = 1313821514;
+      GLB_CHUNK_TYPE_BIN = 5130562;
+      GLB_V1_CONTENT_FORMAT_JSON = 0;
+      GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
+      GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
+    }
+  });
+
   // src/lib/gltf-utils/resolve-url.ts
   function resolveUrl(url, options) {
     const absolute = url.startsWith("data:") || url.startsWith("http:") || url.startsWith("https:");
@@ -1368,10 +1480,24 @@
     assert3(byteLength >= 0 && byteLength <= bufferView.byteLength);
     return { ArrayType, length, byteLength };
   }
-  var TYPES, ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT, ARRAY_TO_COMPONENT_TYPE, ATTRIBUTE_TYPE_TO_COMPONENTS, ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE, ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY;
+  function getMemoryUsageGLTF(gltf) {
+    let { images, bufferViews } = gltf;
+    images = images || [];
+    bufferViews = bufferViews || [];
+    const imageBufferViews = images.map((i2) => i2.bufferView);
+    bufferViews = bufferViews.filter((view) => !imageBufferViews.includes(view));
+    const bufferMemory = bufferViews.reduce((acc, view) => acc + view.byteLength, 0);
+    const pixelCount = images.reduce((acc, image) => {
+      const { width, height } = image.image;
+      return acc + width * height;
+    }, 0);
+    return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);
+  }
+  var MIPMAP_FACTOR, TYPES, ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT, ARRAY_TO_COMPONENT_TYPE, ATTRIBUTE_TYPE_TO_COMPONENTS, ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE, ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY;
   var init_gltf_utils = __esm({
     "src/lib/gltf-utils/gltf-utils.ts"() {
       init_assert3();
+      MIPMAP_FACTOR = 1.33;
       TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
       ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
         [Int8Array, 5120],
@@ -1412,25 +1538,31 @@
   });
 
   // src/lib/api/gltf-scenegraph.ts
-  var DEFAULT_GLTF_JSON, GLTFScenegraph;
+  function makeDefaultGLTFJson() {
+    return {
+      asset: {
+        version: "2.0",
+        generator: "loaders.gl"
+      },
+      buffers: [],
+      extensions: {},
+      extensionsRequired: [],
+      extensionsUsed: []
+    };
+  }
+  var GLTFScenegraph;
   var init_gltf_scenegraph = __esm({
     "src/lib/api/gltf-scenegraph.ts"() {
       init_src3();
       init_src2();
       init_assert3();
       init_gltf_utils();
-      DEFAULT_GLTF_JSON = {
-        asset: {
-          version: "2.0",
-          generator: "loaders.gl"
-        },
-        buffers: []
-      };
       GLTFScenegraph = class {
         constructor(gltf) {
-          this.gltf = gltf || {
-            json: { ...DEFAULT_GLTF_JSON },
-            buffers: []
+          this.gltf = {
+            json: gltf?.json || makeDefaultGLTFJson(),
+            buffers: gltf?.buffers || [],
+            images: gltf?.images || []
           };
           this.sourceBuffers = [];
           this.byteLength = 0;
@@ -1450,10 +1582,15 @@
           const extras = this.json.extras || {};
           return extras[key];
         }
+        hasExtension(extensionName) {
+          const isUsedExtension = this.getUsedExtensions().find((name10) => name10 === extensionName);
+          const isRequiredExtension = this.getRequiredExtensions().find((name10) => name10 === extensionName);
+          return typeof isUsedExtension === "string" || typeof isRequiredExtension === "string";
+        }
         getExtension(extensionName) {
           const isExtension = this.getUsedExtensions().find((name10) => name10 === extensionName);
           const extensions = this.json.extensions || {};
-          return isExtension ? extensions[extensionName] || true : null;
+          return isExtension ? extensions[extensionName] : null;
         }
         getRequiredExtension(extensionName) {
           const isRequired = this.getRequiredExtensions().find((name10) => name10 === extensionName);
@@ -1560,10 +1697,15 @@
           extensions[extensionName] = data;
         }
         removeObjectExtension(object, extensionName) {
-          const extensions = object.extensions || {};
-          const extension = extensions[extensionName];
+          const extensions = object?.extensions || {};
+          if (extensions[extensionName]) {
+            this.json.extensionsRemoved = this.json.extensionsRemoved || [];
+            const extensionsRemoved = this.json.extensionsRemoved;
+            if (!extensionsRemoved.includes(extensionName)) {
+              extensionsRemoved.push(extensionName);
+            }
+          }
           delete extensions[extensionName];
-          return extension;
         }
         addExtension(extensionName, extensionData = {}) {
           assert3(extensionData);
@@ -1592,8 +1734,15 @@
           }
         }
         removeExtension(extensionName) {
-          if (!this.getExtension(extensionName)) {
-            return;
+          if (this.json.extensions?.[extensionName]) {
+            this.json.extensionsRemoved = this.json.extensionsRemoved || [];
+            const extensionsRemoved = this.json.extensionsRemoved;
+            if (!extensionsRemoved.includes(extensionName)) {
+              extensionsRemoved.push(extensionName);
+            }
+          }
+          if (this.json.extensions) {
+            delete this.json.extensions[extensionName];
           }
           if (this.json.extensionsRequired) {
             this._removeStringFromArray(this.json.extensionsRequired, extensionName);
@@ -1601,16 +1750,6 @@
           if (this.json.extensionsUsed) {
             this._removeStringFromArray(this.json.extensionsUsed, extensionName);
           }
-          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;
@@ -1679,14 +1818,14 @@
           this.json.images.push(glTFImage);
           return this.json.images.length - 1;
         }
-        addBufferView(buffer) {
+        addBufferView(buffer, bufferIndex = 0, byteOffset = this.byteLength) {
           const byteLength = buffer.byteLength;
           assert3(Number.isFinite(byteLength));
           this.sourceBuffers = this.sourceBuffers || [];
           this.sourceBuffers.push(buffer);
           const glTFBufferView = {
-            buffer: 0,
-            byteOffset: this.byteLength,
+            buffer: bufferIndex,
+            byteOffset,
             byteLength
           };
           this.byteLength += padToNBytes(byteLength, 4);
@@ -2045,9 +2184,8 @@
       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;
+      scenegraph.removeObjectExtension(bufferView, EXT_MESHOPT_COMPRESSION);
     }
-    return null;
   }
   var EXT_MESHOPT_COMPRESSION, name;
   var init_EXT_meshopt_compression = __esm({
@@ -2106,8 +2244,8 @@
       const extension = scene.getObjectExtension(texture, KHR_TEXTURE_BASISU);
       if (extension) {
         texture.source = extension.source;
+        scene.removeObjectExtension(texture, KHR_TEXTURE_BASISU);
       }
-      scene.removeObjectExtension(texture, KHR_TEXTURE_BASISU);
     }
     scene.removeExtension(KHR_TEXTURE_BASISU);
   }
@@ -2132,7 +2270,6 @@
   var DEFAULT_DRACO_OPTIONS, DracoLoader;
   var init_draco_loader = __esm({
     "../draco/src/draco-loader.ts"() {
-      init_src();
       init_version5();
       DEFAULT_DRACO_OPTIONS = {
         draco: {
@@ -2144,7 +2281,7 @@
       };
       DracoLoader = {
         name: "Draco",
-        id: isBrowser2 ? "draco" : "draco-nodejs",
+        id: "draco",
         module: "draco",
         version: VERSION7,
         worker: true,
@@ -2843,6 +2980,7 @@
     if (decodedData.indices) {
       primitive.indices = getGLTFAccessor(decodedData.indices);
     }
+    scenegraph.removeObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION);
     checkPrimitive(primitive);
   }
   function compressMesh(attributes, indices, mode = 4, options, context) {
@@ -4082,8 +4220,8 @@
   });
   async function decode4(gltfData, options) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
-    const extension = gltfScenegraph.getExtension(EXT_MESHOPT_TRANSFORM);
-    if (!extension) {
+    const hasExtension = gltfScenegraph.hasExtension(EXT_MESHOPT_TRANSFORM);
+    if (!hasExtension) {
       return;
     }
     const materials = gltfData.json.materials || [];
@@ -4217,10 +4355,10 @@
   }
   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 translationMatrix = new Matrix3().set(1, 0, 0, 0, 1, 0, offset[0], offset[1], 1);
+    const rotationMatrix = scratchRotationMatrix.set(Math.cos(rotation), Math.sin(rotation), 0, -Math.sin(rotation), Math.cos(rotation), 0, 0, 0, 1);
     const scaleMatrix = scratchScaleMatrix.set(scale2[0], 0, 0, 0, scale2[1], 0, 0, 0, 1);
-    return translationMatirx.multiplyRight(rotationMatirx).multiplyRight(scaleMatrix);
+    return translationMatrix.multiplyRight(rotationMatrix).multiplyRight(scaleMatrix);
   }
   var EXT_MESHOPT_TRANSFORM, name5, scratchVector, scratchRotationMatrix, scratchScaleMatrix;
   var init_KHR_texture_transform = __esm({
@@ -4402,18 +4540,16 @@
     decode: () => decode8,
     name: () => name9
   });
-  async function decode8(gltfData) {
+  async function decode8(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
-    decodeExtFeatureMetadata(scenegraph);
+    decodeExtFeatureMetadata(scenegraph, options);
   }
-  function decodeExtFeatureMetadata(scenegraph) {
+  function decodeExtFeatureMetadata(scenegraph, options) {
     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 (!extension)
+      return;
+    const schemaClasses = extension.schema?.classes;
+    const { featureTables } = extension;
     if (schemaClasses && featureTables) {
       for (const schemaName in schemaClasses) {
         const schemaClass = schemaClasses[schemaName];
@@ -4423,6 +4559,16 @@
         }
       }
     }
+    const { featureTextures } = extension;
+    if (schemaClasses && featureTextures && options.gltf?.loadImages) {
+      for (const schemaName in schemaClasses) {
+        const schemaClass = schemaClasses[schemaName];
+        const featureTexture = findFeatureTextureByName(featureTextures, schemaName);
+        if (featureTexture) {
+          handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass);
+        }
+      }
+    }
   }
   function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
     for (const propertyName in schemaClass.properties) {
@@ -4435,23 +4581,141 @@
       }
     }
   }
+  function handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass) {
+    const attributeName = featureTexture.class;
+    for (const propertyName in schemaClass.properties) {
+      const featureTextureProperty = featureTexture?.properties?.[propertyName];
+      if (featureTextureProperty) {
+        const data = getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName);
+        featureTextureProperty.data = data;
+      }
+    }
+  }
   function getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
     const bufferView = featureTableProperty.bufferView;
-    let data = scenegraph.getTypedArrayForBufferView(bufferView);
+    const dataArray = scenegraph.getTypedArrayForBufferView(bufferView);
     switch (schemaProperty.type) {
       case "STRING": {
         const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView;
         const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
-        data = getStringAttributes(data, offsetsData, numberOfFeatures);
-        break;
+        return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
+      }
+      default:
+    }
+    return dataArray;
+  }
+  function getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName) {
+    const json = scenegraph.gltf.json;
+    if (!json.meshes) {
+      return [];
+    }
+    const featureTextureTable = [];
+    for (const mesh of json.meshes) {
+      for (const primitive of mesh.primitives) {
+        processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive);
+      }
+    }
+    return featureTextureTable;
+  }
+  function processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive) {
+    const json = scenegraph.gltf.json;
+    const textureData = [];
+    const texCoordAccessorKey = `TEXCOORD_${featureTextureProperty.texture.texCoord}`;
+    const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
+    const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
+    const texCoordArray = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
+    const textureCoordinates = new Float32Array(texCoordArray.buffer, texCoordArray.byteOffset, texCoordArray.length / 4);
+    const textureIndex = featureTextureProperty.texture.index;
+    const texture = json.textures?.[textureIndex];
+    const imageIndex = texture?.source;
+    if (typeof imageIndex !== "undefined") {
+      const image = json.images?.[imageIndex];
+      const mimeType = image?.mimeType;
+      const parsedImage = scenegraph.gltf.images?.[imageIndex];
+      if (parsedImage) {
+        for (let index = 0; index < textureCoordinates.length; index += 2) {
+          const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, featureTextureProperty.channels);
+          textureData.push(value);
+        }
+      }
+    }
+    const featureIndices = [];
+    for (const texelData of textureData) {
+      let index = featureTextureTable.findIndex((item) => item === texelData);
+      if (index === -1) {
+        index = featureTextureTable.push(texelData) - 1;
+      }
+      featureIndices.push(index);
+    }
+    const typedArray = new Uint32Array(featureIndices);
+    const bufferIndex = scenegraph.gltf.buffers.push({
+      arrayBuffer: typedArray.buffer,
+      byteOffset: 0,
+      byteLength: typedArray.byteLength
+    }) - 1;
+    const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
+    const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
+      size: 1,
+      componentType: getComponentTypeFromArray(typedArray),
+      count: typedArray.length
+    });
+    primitive.attributes[attributeName] = accessorIndex;
+  }
+  function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels) {
+    const CHANNELS_MAP = {
+      r: { offset: 0, shift: 0 },
+      g: { offset: 1, shift: 8 },
+      b: { offset: 2, shift: 16 },
+      a: { offset: 3, shift: 24 }
+    };
+    const u = textureCoordinates[index];
+    const v = textureCoordinates[index + 1];
+    let components = 1;
+    if (mimeType && (mimeType.indexOf("image/jpeg") !== -1 || mimeType.indexOf("image/png") !== -1))
+      components = 4;
+    const offset = coordinatesToOffset(u, v, parsedImage, components);
+    let value = 0;
+    for (const c of channels) {
+      const map = CHANNELS_MAP[c];
+      const val = getVal(parsedImage, offset + map.offset);
+      value |= val << map.shift;
+    }
+    return value;
+  }
+  function getVal(parsedImage, offset) {
+    const imageData = getImageData(parsedImage);
+    if (imageData.data.length <= offset) {
+      throw new Error(`${imageData.data.length} <= ${offset}`);
+    }
+    return imageData.data[offset];
+  }
+  function coordinatesToOffset(u, v, parsedImage, componentsCount = 1) {
+    const w = parsedImage.width;
+    const iX = emod(u) * (w - 1);
+    const indX = Math.round(iX);
+    const h = parsedImage.height;
+    const iY = emod(v) * (h - 1);
+    const indY = Math.round(iY);
+    const components = parsedImage.components ? parsedImage.components : componentsCount;
+    const offset = (indY * w + indX) * components;
+    return offset;
+  }
+  function emod(n2) {
+    const a2 = (n2 % 1 + 1) % 1;
+    return a2;
+  }
+  function findFeatureTableByName(featureTables, schemaClassName) {
+    for (const featureTableName in featureTables) {
+      const featureTable = featureTables[featureTableName];
+      if (featureTable.class === schemaClassName) {
+        return featureTable;
       }
-      default:
     }
-    return data;
+    return null;
   }
-  function findFeatureTableByName(featureTables, schemaClassName) {
-    for (const featureTableName in featureTables) {
-      const featureTable = featureTables[featureTableName];
+  function findFeatureTextureByName(featureTextures, schemaClassName) {
+    for (const featureTexturesName in featureTextures) {
+      const featureTable = featureTextures[featureTexturesName];
       if (featureTable.class === schemaClassName) {
         return featureTable;
       }
@@ -4476,6 +4740,8 @@
   var init_EXT_feature_metadata = __esm({
     "src/lib/extensions/deprecated/EXT_feature_metadata.ts"() {
       init_gltf_scenegraph();
+      init_src3();
+      init_gltf_utils();
       EXT_FEATURE_METADATA = "EXT_feature_metadata";
       name9 = EXT_FEATURE_METADATA;
     }
@@ -4627,560 +4893,125 @@
           this._updateMaterial(json);
         }
         _addAsset(json) {
-          json.asset = json.asset || {};
-          json.asset.version = "2.0";
-          json.asset.generator = json.asset.generator || "Normalized to glTF 2.0 by loaders.gl";
-        }
-        _convertTopLevelObjectsToArrays(json) {
-          for (const arrayName in GLTF_ARRAYS) {
-            this._convertTopLevelObjectToArray(json, arrayName);
-          }
-        }
-        _convertTopLevelObjectToArray(json, mapName) {
-          const objectMap = json[mapName];
-          if (!objectMap || Array.isArray(objectMap)) {
-            return;
-          }
-          json[mapName] = [];
-          for (const id in objectMap) {
-            const object = objectMap[id];
-            object.id = object.id || id;
-            const index = json[mapName].length;
-            json[mapName].push(object);
-            this.idToIndexMap[mapName][id] = index;
-          }
-        }
-        _convertObjectIdsToArrayIndices(json) {
-          for (const arrayName in GLTF_ARRAYS) {
-            this._convertIdsToIndices(json, arrayName);
-          }
-          if ("scene" in json) {
-            json.scene = this._convertIdToIndex(json.scene, "scene");
-          }
-          for (const texture of json.textures) {
-            this._convertTextureIds(texture);
-          }
-          for (const mesh of json.meshes) {
-            this._convertMeshIds(mesh);
-          }
-          for (const node2 of json.nodes) {
-            this._convertNodeIds(node2);
-          }
-          for (const node2 of json.scenes) {
-            this._convertSceneIds(node2);
-          }
-        }
-        _convertTextureIds(texture) {
-          if (texture.source) {
-            texture.source = this._convertIdToIndex(texture.source, "image");
-          }
-        }
-        _convertMeshIds(mesh) {
-          for (const primitive of mesh.primitives) {
-            const { attributes, indices, material } = primitive;
-            for (const attributeName in attributes) {
-              attributes[attributeName] = this._convertIdToIndex(attributes[attributeName], "accessor");
-            }
-            if (indices) {
-              primitive.indices = this._convertIdToIndex(indices, "accessor");
-            }
-            if (material) {
-              primitive.material = this._convertIdToIndex(material, "material");
-            }
-          }
-        }
-        _convertNodeIds(node2) {
-          if (node2.children) {
-            node2.children = node2.children.map((child) => this._convertIdToIndex(child, "node"));
-          }
-          if (node2.meshes) {
-            node2.meshes = node2.meshes.map((mesh) => this._convertIdToIndex(mesh, "mesh"));
-          }
-        }
-        _convertSceneIds(scene) {
-          if (scene.nodes) {
-            scene.nodes = scene.nodes.map((node2) => this._convertIdToIndex(node2, "node"));
-          }
-        }
-        _convertIdsToIndices(json, topLevelArrayName) {
-          if (!json[topLevelArrayName]) {
-            console.warn(`gltf v1: json doesn't contain attribute ${topLevelArrayName}`);
-            json[topLevelArrayName] = [];
-          }
-          for (const object of json[topLevelArrayName]) {
-            for (const key in object) {
-              const id = object[key];
-              const index = this._convertIdToIndex(id, key);
-              object[key] = index;
-            }
-          }
-        }
-        _convertIdToIndex(id, key) {
-          const arrayName = GLTF_KEYS[key];
-          if (arrayName in this.idToIndexMap) {
-            const index = this.idToIndexMap[arrayName][id];
-            if (!Number.isFinite(index)) {
-              throw new Error(`gltf v1: failed to resolve ${key} with id ${id}`);
-            }
-            return index;
-          }
-          return id;
-        }
-        _updateObjects(json) {
-          for (const buffer of this.json.buffers) {
-            delete buffer.type;
-          }
-        }
-        _updateMaterial(json) {
-          for (const material of json.materials) {
-            material.pbrMetallicRoughness = {
-              baseColorFactor: [1, 1, 1, 1],
-              metallicFactor: 1,
-              roughnessFactor: 1
-            };
-            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 };
-            }
-          }
-        }
-      };
-    }
-  });
-
-  // src/lib/api/post-process-gltf.ts
-  function getBytesFromComponentType(componentType) {
-    return BYTES2[componentType];
-  }
-  function getSizeFromAccessorType(type) {
-    return COMPONENTS2[type];
-  }
-  function postProcessGLTF(gltf, options) {
-    return new GLTFPostProcessor().postProcess(gltf, options);
-  }
-  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();
-      COMPONENTS2 = {
-        SCALAR: 1,
-        VEC2: 2,
-        VEC3: 3,
-        VEC4: 4,
-        MAT2: 4,
-        MAT3: 9,
-        MAT4: 16
-      };
-      BYTES2 = {
-        5120: 1,
-        5121: 1,
-        5122: 2,
-        5123: 2,
-        5125: 4,
-        5126: 4
-      };
-      GL_SAMPLER = {
-        TEXTURE_MAG_FILTER: 10240,
-        TEXTURE_MIN_FILTER: 10241,
-        TEXTURE_WRAP_S: 10242,
-        TEXTURE_WRAP_T: 10243,
-        REPEAT: 10497,
-        LINEAR: 9729,
-        NEAREST_MIPMAP_LINEAR: 9986
-      };
-      SAMPLER_PARAMETER_GLTF_TO_GL = {
-        magFilter: GL_SAMPLER.TEXTURE_MAG_FILTER,
-        minFilter: GL_SAMPLER.TEXTURE_MIN_FILTER,
-        wrapS: GL_SAMPLER.TEXTURE_WRAP_S,
-        wrapT: GL_SAMPLER.TEXTURE_WRAP_T
-      };
-      DEFAULT_SAMPLER = {
-        [GL_SAMPLER.TEXTURE_MAG_FILTER]: GL_SAMPLER.LINEAR,
-        [GL_SAMPLER.TEXTURE_MIN_FILTER]: GL_SAMPLER.NEAREST_MIPMAP_LINEAR,
-        [GL_SAMPLER.TEXTURE_WRAP_S]: GL_SAMPLER.REPEAT,
-        [GL_SAMPLER.TEXTURE_WRAP_T]: GL_SAMPLER.REPEAT
-      };
-      GLTFPostProcessor = class {
-        constructor() {
-          this.baseUri = "";
-          this.json = {};
-          this.buffers = [];
-          this.images = [];
-        }
-        postProcess(gltf, options = {}) {
-          const { json, buffers = [], images = [], baseUri = "" } = gltf;
-          assert3(json);
-          this.baseUri = baseUri;
-          this.json = json;
-          this.buffers = buffers;
-          this.images = images;
-          this._resolveTree(this.json, options);
-          return this.json;
-        }
-        _resolveTree(json, options = {}) {
-          if (json.bufferViews) {
-            json.bufferViews = json.bufferViews.map((bufView, i2) => this._resolveBufferView(bufView, i2));
-          }
-          if (json.images) {
-            json.images = json.images.map((image, i2) => this._resolveImage(image, i2));
-          }
-          if (json.samplers) {
-            json.samplers = json.samplers.map((sampler, i2) => this._resolveSampler(sampler, i2));
-          }
-          if (json.textures) {
-            json.textures = json.textures.map((texture, i2) => this._resolveTexture(texture, i2));
-          }
-          if (json.accessors) {
-            json.accessors = json.accessors.map((accessor, i2) => this._resolveAccessor(accessor, i2));
-          }
-          if (json.materials) {
-            json.materials = json.materials.map((material, i2) => this._resolveMaterial(material, i2));
-          }
-          if (json.meshes) {
-            json.meshes = json.meshes.map((mesh, i2) => this._resolveMesh(mesh, i2));
-          }
-          if (json.nodes) {
-            json.nodes = json.nodes.map((node2, i2) => this._resolveNode(node2, i2));
-          }
-          if (json.skins) {
-            json.skins = json.skins.map((skin, i2) => this._resolveSkin(skin, i2));
-          }
-          if (json.scenes) {
-            json.scenes = json.scenes.map((scene, i2) => this._resolveScene(scene, i2));
-          }
-          if (json.scene !== void 0) {
-            json.scene = json.scenes[this.json.scene];
-          }
-        }
-        getScene(index) {
-          return this._get("scenes", index);
-        }
-        getNode(index) {
-          return this._get("nodes", index);
-        }
-        getSkin(index) {
-          return this._get("skins", index);
-        }
-        getMesh(index) {
-          return this._get("meshes", index);
-        }
-        getMaterial(index) {
-          return this._get("materials", index);
-        }
-        getAccessor(index) {
-          return this._get("accessors", index);
-        }
-        getCamera(index) {
-          return null;
-        }
-        getTexture(index) {
-          return this._get("textures", index);
-        }
-        getSampler(index) {
-          return this._get("samplers", index);
-        }
-        getImage(index) {
-          return this._get("images", index);
-        }
-        getBufferView(index) {
-          return this._get("bufferViews", index);
-        }
-        getBuffer(index) {
-          return this._get("buffers", index);
-        }
-        _get(array, index) {
-          if (typeof index === "object") {
-            return index;
-          }
-          const object = this.json[array] && this.json[array][index];
-          if (!object) {
-            console.warn(`glTF file error: Could not find ${array}[${index}]`);
-          }
-          return object;
-        }
-        _resolveScene(scene, index) {
-          scene.id = scene.id || `scene-${index}`;
-          scene.nodes = (scene.nodes || []).map((node2) => this.getNode(node2));
-          return scene;
-        }
-        _resolveNode(node2, index) {
-          node2.id = node2.id || `node-${index}`;
-          if (node2.children) {
-            node2.children = node2.children.map((child) => this.getNode(child));
-          }
-          if (node2.mesh !== void 0) {
-            node2.mesh = this.getMesh(node2.mesh);
-          } else if (node2.meshes !== void 0 && node2.meshes.length) {
-            node2.mesh = node2.meshes.reduce((accum, meshIndex) => {
-              const mesh = this.getMesh(meshIndex);
-              accum.id = mesh.id;
-              accum.primitives = accum.primitives.concat(mesh.primitives);
-              return accum;
-            }, { primitives: [] });
-          }
-          if (node2.camera !== void 0) {
-            node2.camera = this.getCamera(node2.camera);
-          }
-          if (node2.skin !== void 0) {
-            node2.skin = this.getSkin(node2.skin);
-          }
-          return node2;
+          json.asset = json.asset || {};
+          json.asset.version = "2.0";
+          json.asset.generator = json.asset.generator || "Normalized to glTF 2.0 by loaders.gl";
         }
-        _resolveSkin(skin, index) {
-          skin.id = skin.id || `skin-${index}`;
-          skin.inverseBindMatrices = this.getAccessor(skin.inverseBindMatrices);
-          return skin;
-        }
-        _resolveMesh(mesh, index) {
-          mesh.id = mesh.id || `mesh-${index}`;
-          if (mesh.primitives) {
-            mesh.primitives = mesh.primitives.map((primitive) => {
-              primitive = { ...primitive };
-              const attributes = primitive.attributes;
-              primitive.attributes = {};
-              for (const attribute in attributes) {
-                primitive.attributes[attribute] = this.getAccessor(attributes[attribute]);
-              }
-              if (primitive.indices !== void 0) {
-                primitive.indices = this.getAccessor(primitive.indices);
-              }
-              if (primitive.material !== void 0) {
-                primitive.material = this.getMaterial(primitive.material);
-              }
-              return primitive;
-            });
+        _convertTopLevelObjectsToArrays(json) {
+          for (const arrayName in GLTF_ARRAYS) {
+            this._convertTopLevelObjectToArray(json, arrayName);
           }
-          return mesh;
         }
-        _resolveMaterial(material, index) {
-          material.id = material.id || `material-${index}`;
-          if (material.normalTexture) {
-            material.normalTexture = { ...material.normalTexture };
-            material.normalTexture.texture = this.getTexture(material.normalTexture.index);
+        _convertTopLevelObjectToArray(json, mapName) {
+          const objectMap = json[mapName];
+          if (!objectMap || Array.isArray(objectMap)) {
+            return;
           }
-          if (material.occlusionTexture) {
-            material.occlustionTexture = { ...material.occlustionTexture };
-            material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);
+          json[mapName] = [];
+          for (const id in objectMap) {
+            const object = objectMap[id];
+            object.id = object.id || id;
+            const index = json[mapName].length;
+            json[mapName].push(object);
+            this.idToIndexMap[mapName][id] = index;
           }
-          if (material.emissiveTexture) {
-            material.emmisiveTexture = { ...material.emmisiveTexture };
-            material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);
+        }
+        _convertObjectIdsToArrayIndices(json) {
+          for (const arrayName in GLTF_ARRAYS) {
+            this._convertIdsToIndices(json, arrayName);
           }
-          if (!material.emissiveFactor) {
-            material.emissiveFactor = material.emmisiveTexture ? [1, 1, 1] : [0, 0, 0];
+          if ("scene" in json) {
+            json.scene = this._convertIdToIndex(json.scene, "scene");
           }
-          if (material.pbrMetallicRoughness) {
-            material.pbrMetallicRoughness = { ...material.pbrMetallicRoughness };
-            const mr = material.pbrMetallicRoughness;
-            if (mr.baseColorTexture) {
-              mr.baseColorTexture = { ...mr.baseColorTexture };
-              mr.baseColorTexture.texture = this.getTexture(mr.baseColorTexture.index);
-            }
-            if (mr.metallicRoughnessTexture) {
-              mr.metallicRoughnessTexture = { ...mr.metallicRoughnessTexture };
-              mr.metallicRoughnessTexture.texture = this.getTexture(mr.metallicRoughnessTexture.index);
-            }
+          for (const texture of json.textures) {
+            this._convertTextureIds(texture);
           }
-          return material;
-        }
-        _resolveAccessor(accessor, index) {
-          accessor.id = accessor.id || `accessor-${index}`;
-          if (accessor.bufferView !== void 0) {
-            accessor.bufferView = this.getBufferView(accessor.bufferView);
+          for (const mesh of json.meshes) {
+            this._convertMeshIds(mesh);
           }
-          accessor.bytesPerComponent = getBytesFromComponentType(accessor.componentType);
-          accessor.components = getSizeFromAccessorType(accessor.type);
-          accessor.bytesPerElement = accessor.bytesPerComponent * accessor.components;
-          if (accessor.bufferView) {
-            const buffer = accessor.bufferView.buffer;
-            const { ArrayType, byteLength } = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);
-            const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
-            let cutBuffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
-            if (accessor.bufferView.byteStride) {
-              cutBuffer = this._getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
-            }
-            accessor.value = new ArrayType(cutBuffer);
+          for (const node2 of json.nodes) {
+            this._convertNodeIds(node2);
           }
-          return accessor;
-        }
-        _getValueFromInterleavedBuffer(buffer, byteOffset, byteStride, bytesPerElement, count) {
-          const result = new Uint8Array(count * bytesPerElement);
-          for (let i2 = 0; i2 < count; i2++) {
-            const elementOffset = byteOffset + i2 * byteStride;
-            result.set(new Uint8Array(buffer.arrayBuffer.slice(elementOffset, elementOffset + bytesPerElement)), i2 * bytesPerElement);
+          for (const node2 of json.scenes) {
+            this._convertSceneIds(node2);
           }
-          return result.buffer;
         }
-        _resolveTexture(texture, index) {
-          texture.id = texture.id || `texture-${index}`;
-          texture.sampler = "sampler" in texture ? this.getSampler(texture.sampler) : DEFAULT_SAMPLER;
-          texture.source = this.getImage(texture.source);
-          return texture;
+        _convertTextureIds(texture) {
+          if (texture.source) {
+            texture.source = this._convertIdToIndex(texture.source, "image");
+          }
         }
-        _resolveSampler(sampler, index) {
-          sampler.id = sampler.id || `sampler-${index}`;
-          sampler.parameters = {};
-          for (const key in sampler) {
-            const glEnum = this._enumSamplerParameter(key);
-            if (glEnum !== void 0) {
-              sampler.parameters[glEnum] = sampler[key];
+        _convertMeshIds(mesh) {
+          for (const primitive of mesh.primitives) {
+            const { attributes, indices, material } = primitive;
+            for (const attributeName in attributes) {
+              attributes[attributeName] = this._convertIdToIndex(attributes[attributeName], "accessor");
+            }
+            if (indices) {
+              primitive.indices = this._convertIdToIndex(indices, "accessor");
+            }
+            if (material) {
+              primitive.material = this._convertIdToIndex(material, "material");
             }
           }
-          return sampler;
-        }
-        _enumSamplerParameter(key) {
-          return SAMPLER_PARAMETER_GLTF_TO_GL[key];
         }
-        _resolveImage(image, index) {
-          image.id = image.id || `image-${index}`;
-          if (image.bufferView !== void 0) {
-            image.bufferView = this.getBufferView(image.bufferView);
+        _convertNodeIds(node2) {
+          if (node2.children) {
+            node2.children = node2.children.map((child) => this._convertIdToIndex(child, "node"));
           }
-          const preloadedImage = this.images[index];
-          if (preloadedImage) {
-            image.image = preloadedImage;
+          if (node2.meshes) {
+            node2.meshes = node2.meshes.map((mesh) => this._convertIdToIndex(mesh, "mesh"));
           }
-          return image;
         }
-        _resolveBufferView(bufferView, index) {
-          const bufferIndex = bufferView.buffer;
-          const result = {
-            id: `bufferView-${index}`,
-            ...bufferView,
-            buffer: this.buffers[bufferIndex]
-          };
-          const arrayBuffer = this.buffers[bufferIndex].arrayBuffer;
-          let byteOffset = this.buffers[bufferIndex].byteOffset || 0;
-          if ("byteOffset" in bufferView) {
-            byteOffset += bufferView.byteOffset;
+        _convertSceneIds(scene) {
+          if (scene.nodes) {
+            scene.nodes = scene.nodes.map((node2) => this._convertIdToIndex(node2, "node"));
           }
-          result.data = new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
-          return result;
         }
-        _resolveCamera(camera, index) {
-          camera.id = camera.id || `camera-${index}`;
-          if (camera.perspective) {
+        _convertIdsToIndices(json, topLevelArrayName) {
+          if (!json[topLevelArrayName]) {
+            console.warn(`gltf v1: json doesn't contain attribute ${topLevelArrayName}`);
+            json[topLevelArrayName] = [];
           }
-          if (camera.orthographic) {
+          for (const object of json[topLevelArrayName]) {
+            for (const key in object) {
+              const id = object[key];
+              const index = this._convertIdToIndex(id, key);
+              object[key] = index;
+            }
           }
-          return camera;
         }
-      };
-    }
-  });
-
-  // src/lib/parsers/parse-glb.ts
-  function getMagicString2(dataView, byteOffset = 0) {
-    return `${String.fromCharCode(dataView.getUint8(byteOffset + 0))}${String.fromCharCode(dataView.getUint8(byteOffset + 1))}${String.fromCharCode(dataView.getUint8(byteOffset + 2))}${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;
-  }
-  function isGLB(arrayBuffer, byteOffset = 0, options = {}) {
-    const dataView = new DataView(arrayBuffer);
-    const { magic = MAGIC_glTF } = options;
-    const magic1 = dataView.getUint32(byteOffset, false);
-    return magic1 === magic || magic1 === MAGIC_glTF;
-  }
-  function parseGLBSync(glb, arrayBuffer, byteOffset = 0, options = {}) {
-    const dataView = new DataView(arrayBuffer);
-    const type = getMagicString2(dataView, byteOffset + 0);
-    const version = dataView.getUint32(byteOffset + 4, LE);
-    const byteLength = dataView.getUint32(byteOffset + 8, LE);
-    Object.assign(glb, {
-      header: {
-        byteOffset,
-        byteLength,
-        hasBinChunk: false
-      },
-      type,
-      version,
-      json: {},
-      binChunks: []
-    });
-    byteOffset += GLB_FILE_HEADER_SIZE;
-    switch (glb.version) {
-      case 1:
-        return parseGLBV1(glb, dataView, byteOffset);
-      case 2:
-        return parseGLBV2(glb, dataView, byteOffset, options = {});
-      default:
-        throw new Error(`Invalid GLB version ${glb.version}. Only supports v1 and v2.`);
-    }
-  }
-  function parseGLBV1(glb, dataView, byteOffset) {
-    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;
-    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) {
-    assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
-    parseGLBChunksSync(glb, dataView, byteOffset, options);
-    return byteOffset + glb.header.byteLength;
-  }
-  function parseGLBChunksSync(glb, dataView, byteOffset, options) {
-    while (byteOffset + 8 <= glb.header.byteLength) {
-      const chunkLength = dataView.getUint32(byteOffset + 0, LE);
-      const chunkFormat = dataView.getUint32(byteOffset + 4, LE);
-      byteOffset += GLB_CHUNK_HEADER_SIZE;
-      switch (chunkFormat) {
-        case GLB_CHUNK_TYPE_JSON:
-          parseJSONChunk(glb, dataView, byteOffset, chunkLength);
-          break;
-        case GLB_CHUNK_TYPE_BIN:
-          parseBINChunk(glb, dataView, byteOffset, chunkLength);
-          break;
-        case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:
-          if (!options.strict) {
-            parseJSONChunk(glb, dataView, byteOffset, chunkLength);
+        _convertIdToIndex(id, key) {
+          const arrayName = GLTF_KEYS[key];
+          if (arrayName in this.idToIndexMap) {
+            const index = this.idToIndexMap[arrayName][id];
+            if (!Number.isFinite(index)) {
+              throw new Error(`gltf v1: failed to resolve ${key} with id ${id}`);
+            }
+            return index;
           }
-          break;
-        case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:
-          if (!options.strict) {
-            parseBINChunk(glb, dataView, byteOffset, chunkLength);
+          return id;
+        }
+        _updateObjects(json) {
+          for (const buffer of this.json.buffers) {
+            delete buffer.type;
           }
-          break;
-        default:
-          break;
-      }
-      byteOffset += padToNBytes(chunkLength, 4);
-    }
-    return byteOffset;
-  }
-  function parseJSONChunk(glb, dataView, byteOffset, chunkLength) {
-    const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);
-    const textDecoder = new TextDecoder("utf8");
-    const jsonText = textDecoder.decode(jsonChunk);
-    glb.json = JSON.parse(jsonText);
-    return padToNBytes(chunkLength, 4);
-  }
-  function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
-    glb.header.hasBinChunk = true;
-    glb.binChunks.push({
-      byteOffset,
-      byteLength: chunkLength,
-      arrayBuffer: dataView.buffer
-    });
-    return padToNBytes(chunkLength, 4);
-  }
-  var MAGIC_glTF, GLB_FILE_HEADER_SIZE, GLB_CHUNK_HEADER_SIZE, GLB_CHUNK_TYPE_JSON, GLB_CHUNK_TYPE_BIN, GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED, GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED, GLB_V1_CONTENT_FORMAT_JSON, LE;
-  var init_parse_glb = __esm({
-    "src/lib/parsers/parse-glb.ts"() {
-      init_src2();
-      MAGIC_glTF = 1735152710;
-      GLB_FILE_HEADER_SIZE = 12;
-      GLB_CHUNK_HEADER_SIZE = 8;
-      GLB_CHUNK_TYPE_JSON = 1313821514;
-      GLB_CHUNK_TYPE_BIN = 5130562;
-      GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
-      GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
-      GLB_V1_CONTENT_FORMAT_JSON = 0;
-      LE = true;
+        }
+        _updateMaterial(json) {
+          for (const material of json.materials) {
+            material.pbrMetallicRoughness = {
+              baseColorFactor: [1, 1, 1, 1],
+              metallicFactor: 1,
+              roughnessFactor: 1
+            };
+            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 };
+            }
+          }
+        }
+      };
     }
   });
 
@@ -5189,18 +5020,14 @@
     parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);
     normalizeGLTFV1(gltf, { normalize: options?.gltf?.normalize });
     preprocessExtensions(gltf, options, context);
-    const promises = [];
     if (options?.gltf?.loadBuffers && gltf.json.buffers) {
       await loadBuffers(gltf, options, context);
     }
     if (options?.gltf?.loadImages) {
-      const promise2 = loadImages(gltf, options, context);
-      promises.push(promise2);
+      await loadImages(gltf, options, context);
     }
-    const promise = decodeExtensions(gltf, options, context);
-    promises.push(promise);
-    await Promise.all(promises);
-    return options?.gltf?.postProcess ? postProcessGLTF(gltf, options) : gltf;
+    await decodeExtensions(gltf, options, context);
+    return gltf;
   }
   function parseGLTFContainerSync(gltf, data, byteOffset, options) {
     if (options.uri) {
@@ -5309,16 +5136,15 @@
   }
   var init_parse_gltf = __esm({
     "src/lib/parsers/parse-gltf.ts"() {
-      init_src4();
-      init_src3();
       init_src2();
+      init_src3();
+      init_src4();
       init_assert3();
+      init_parse_glb();
       init_resolve_url();
       init_get_typed_array();
       init_gltf_extensions();
       init_normalize_gltf_v1();
-      init_post_process_gltf();
-      init_parse_glb();
     }
   });
 
@@ -5351,8 +5177,7 @@
             normalize: true,
             loadBuffers: true,
             loadImages: true,
-            decompressMeshes: true,
-            postProcess: true
+            decompressMeshes: true
           },
           log: console
         },
@@ -5362,7 +5187,8 @@
           decompress: "gltf.decompressMeshes",
           postProcess: "gltf.postProcess",
           gltf: {
-            decompress: "gltf.decompressMeshes"
+            decompress: "gltf.decompressMeshes",
+            postProcess: "removed in v4"
           }
         }
       };
@@ -5374,51 +5200,51 @@
     const { magic = MAGIC_glTF2, version = 2, json = {}, binary } = glb;
     const byteOffsetStart = byteOffset;
     if (dataView) {
-      dataView.setUint32(byteOffset + 0, magic, LE2);
-      dataView.setUint32(byteOffset + 4, version, LE2);
-      dataView.setUint32(byteOffset + 8, 0, LE2);
+      dataView.setUint32(byteOffset + 0, magic, LE);
+      dataView.setUint32(byteOffset + 4, version, LE);
+      dataView.setUint32(byteOffset + 8, 0, LE);
     }
     const byteOffsetFileLength = byteOffset + 8;
     byteOffset += 12;
     const byteOffsetJsonHeader = byteOffset;
     if (dataView) {
-      dataView.setUint32(byteOffset + 0, 0, LE2);
-      dataView.setUint32(byteOffset + 4, MAGIC_JSON, LE2);
+      dataView.setUint32(byteOffset + 0, 0, LE);
+      dataView.setUint32(byteOffset + 4, MAGIC_JSON, LE);
     }
     byteOffset += 8;
     const jsonString = JSON.stringify(json);
     byteOffset = copyPaddedStringToDataView(dataView, byteOffset, jsonString, 4);
     if (dataView) {
       const jsonByteLength = byteOffset - byteOffsetJsonHeader - 8;
-      dataView.setUint32(byteOffsetJsonHeader + 0, jsonByteLength, LE2);
+      dataView.setUint32(byteOffsetJsonHeader + 0, jsonByteLength, LE);
     }
     if (binary) {
       const byteOffsetBinHeader = byteOffset;
       if (dataView) {
-        dataView.setUint32(byteOffset + 0, 0, LE2);
-        dataView.setUint32(byteOffset + 4, MAGIC_BIN, LE2);
+        dataView.setUint32(byteOffset + 0, 0, LE);
+        dataView.setUint32(byteOffset + 4, MAGIC_BIN, LE);
       }
       byteOffset += 8;
       byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, binary, 4);
       if (dataView) {
         const binByteLength = byteOffset - byteOffsetBinHeader - 8;
-        dataView.setUint32(byteOffsetBinHeader + 0, binByteLength, LE2);
+        dataView.setUint32(byteOffsetBinHeader + 0, binByteLength, LE);
       }
     }
     if (dataView) {
       const fileByteLength = byteOffset - byteOffsetStart;
-      dataView.setUint32(byteOffsetFileLength, fileByteLength, LE2);
+      dataView.setUint32(byteOffsetFileLength, fileByteLength, LE);
     }
     return byteOffset;
   }
-  var MAGIC_glTF2, MAGIC_JSON, MAGIC_BIN, LE2;
+  var MAGIC_glTF2, MAGIC_JSON, MAGIC_BIN, LE;
   var init_encode_glb = __esm({
     "src/lib/encoders/encode-glb.ts"() {
       init_src2();
       MAGIC_glTF2 = 1179937895;
       MAGIC_JSON = 1313821514;
       MAGIC_BIN = 5130562;
-      LE2 = true;
+      LE = true;
     }
   });
 
@@ -5532,6 +5358,380 @@
     }
   });
 
+  // src/lib/api/post-process-gltf.ts
+  function makeDefaultSampler() {
+    return {
+      id: "default-sampler",
+      parameters: DEFAULT_SAMPLER_PARAMETERS
+    };
+  }
+  function getBytesFromComponentType(componentType) {
+    return BYTES2[componentType];
+  }
+  function getSizeFromAccessorType(type) {
+    return COMPONENTS2[type];
+  }
+  function postProcessGLTF(gltf, options) {
+    return new GLTFPostProcessor().postProcess(gltf, options);
+  }
+  var COMPONENTS2, BYTES2, GL_SAMPLER, SAMPLER_PARAMETER_GLTF_TO_GL, DEFAULT_SAMPLER_PARAMETERS, GLTFPostProcessor;
+  var init_post_process_gltf = __esm({
+    "src/lib/api/post-process-gltf.ts"() {
+      init_assert3();
+      init_gltf_utils();
+      COMPONENTS2 = {
+        SCALAR: 1,
+        VEC2: 2,
+        VEC3: 3,
+        VEC4: 4,
+        MAT2: 4,
+        MAT3: 9,
+        MAT4: 16
+      };
+      BYTES2 = {
+        5120: 1,
+        5121: 1,
+        5122: 2,
+        5123: 2,
+        5125: 4,
+        5126: 4
+      };
+      GL_SAMPLER = {
+        TEXTURE_MAG_FILTER: 10240,
+        TEXTURE_MIN_FILTER: 10241,
+        TEXTURE_WRAP_S: 10242,
+        TEXTURE_WRAP_T: 10243,
+        REPEAT: 10497,
+        LINEAR: 9729,
+        NEAREST_MIPMAP_LINEAR: 9986
+      };
+      SAMPLER_PARAMETER_GLTF_TO_GL = {
+        magFilter: GL_SAMPLER.TEXTURE_MAG_FILTER,
+        minFilter: GL_SAMPLER.TEXTURE_MIN_FILTER,
+        wrapS: GL_SAMPLER.TEXTURE_WRAP_S,
+        wrapT: GL_SAMPLER.TEXTURE_WRAP_T
+      };
+      DEFAULT_SAMPLER_PARAMETERS = {
+        [GL_SAMPLER.TEXTURE_MAG_FILTER]: GL_SAMPLER.LINEAR,
+        [GL_SAMPLER.TEXTURE_MIN_FILTER]: GL_SAMPLER.NEAREST_MIPMAP_LINEAR,
+        [GL_SAMPLER.TEXTURE_WRAP_S]: GL_SAMPLER.REPEAT,
+        [GL_SAMPLER.TEXTURE_WRAP_T]: GL_SAMPLER.REPEAT
+      };
+      GLTFPostProcessor = class {
+        constructor() {
+          this.baseUri = "";
+          this.buffers = [];
+          this.images = [];
+        }
+        postProcess(gltf, options = {}) {
+          const { json, buffers = [], images = [] } = gltf;
+          const { baseUri = "" } = gltf;
+          assert3(json);
+          this.baseUri = baseUri;
+          this.buffers = buffers;
+          this.images = images;
+          this.jsonUnprocessed = json;
+          this.json = this._resolveTree(gltf.json, options);
+          return this.json;
+        }
+        _resolveTree(gltf, options = {}) {
+          const json = { ...gltf };
+          this.json = json;
+          if (gltf.bufferViews) {
+            json.bufferViews = gltf.bufferViews.map((bufView, i2) => this._resolveBufferView(bufView, i2));
+          }
+          if (gltf.images) {
+            json.images = gltf.images.map((image, i2) => this._resolveImage(image, i2));
+          }
+          if (gltf.samplers) {
+            json.samplers = gltf.samplers.map((sampler, i2) => this._resolveSampler(sampler, i2));
+          }
+          if (gltf.textures) {
+            json.textures = gltf.textures.map((texture, i2) => this._resolveTexture(texture, i2));
+          }
+          if (gltf.accessors) {
+            json.accessors = gltf.accessors.map((accessor, i2) => this._resolveAccessor(accessor, i2));
+          }
+          if (gltf.materials) {
+            json.materials = gltf.materials.map((material, i2) => this._resolveMaterial(material, i2));
+          }
+          if (gltf.meshes) {
+            json.meshes = gltf.meshes.map((mesh, i2) => this._resolveMesh(mesh, i2));
+          }
+          if (gltf.nodes) {
+            json.nodes = gltf.nodes.map((node2, i2) => this._resolveNode(node2, i2));
+            json.nodes = json.nodes.map((node2, i2) => this._resolveNodeChildren(node2));
+          }
+          if (gltf.skins) {
+            json.skins = gltf.skins.map((skin, i2) => this._resolveSkin(skin, i2));
+          }
+          if (gltf.scenes) {
+            json.scenes = gltf.scenes.map((scene, i2) => this._resolveScene(scene, i2));
+          }
+          if (typeof this.json.scene === "number" && json.scenes) {
+            json.scene = json.scenes[this.json.scene];
+          }
+          return json;
+        }
+        getScene(index) {
+          return this._get(this.json.scenes, index);
+        }
+        getNode(index) {
+          return this._get(this.json.nodes, index);
+        }
+        getSkin(index) {
+          return this._get(this.json.skins, index);
+        }
+        getMesh(index) {
+          return this._get(this.json.meshes, index);
+        }
+        getMaterial(index) {
+          return this._get(this.json.materials, index);
+        }
+        getAccessor(index) {
+          return this._get(this.json.accessors, index);
+        }
+        getCamera(index) {
+          return this._get(this.json.cameras, index);
+        }
+        getTexture(index) {
+          return this._get(this.json.textures, index);
+        }
+        getSampler(index) {
+          return this._get(this.json.samplers, index);
+        }
+        getImage(index) {
+          return this._get(this.json.images, index);
+        }
+        getBufferView(index) {
+          return this._get(this.json.bufferViews, index);
+        }
+        getBuffer(index) {
+          return this._get(this.json.buffers, index);
+        }
+        _get(array, index) {
+          if (typeof index === "object") {
+            return index;
+          }
+          const object = array && array[index];
+          if (!object) {
+            console.warn(`glTF file error: Could not find ${array}[${index}]`);
+          }
+          return object;
+        }
+        _resolveScene(scene, index) {
+          return {
+            ...scene,
+            id: scene.id || `scene-${index}`,
+            nodes: (scene.nodes || []).map((node2) => this.getNode(node2))
+          };
+        }
+        _resolveNode(gltfNode, index) {
+          const node2 = {
+            ...gltfNode,
+            id: gltfNode?.id || `node-${index}`
+          };
+          if (gltfNode.mesh !== void 0) {
+            node2.mesh = this.getMesh(gltfNode.mesh);
+          }
+          if (gltfNode.camera !== void 0) {
+            node2.camera = this.getCamera(gltfNode.camera);
+          }
+          if (gltfNode.skin !== void 0) {
+            node2.skin = this.getSkin(gltfNode.skin);
+          }
+          if (gltfNode.meshes !== void 0 && gltfNode.meshes.length) {
+            node2.mesh = gltfNode.meshes.reduce((accum, meshIndex) => {
+              const mesh = this.getMesh(meshIndex);
+              accum.id = mesh.id;
+              accum.primitives = accum.primitives.concat(mesh.primitives);
+              return accum;
+            }, { primitives: [] });
+          }
+          return node2;
+        }
+        _resolveNodeChildren(node2) {
+          if (node2.children) {
+            node2.children = node2.children.map((child) => this.getNode(child));
+          }
+          return node2;
+        }
+        _resolveSkin(gltfSkin, index) {
+          const inverseBindMatrices = typeof gltfSkin.inverseBindMatrices === "number" ? this.getAccessor(gltfSkin.inverseBindMatrices) : void 0;
+          return {
+            ...gltfSkin,
+            id: gltfSkin.id || `skin-${index}`,
+            inverseBindMatrices
+          };
+        }
+        _resolveMesh(gltfMesh, index) {
+          const mesh = {
+            ...gltfMesh,
+            id: gltfMesh.id || `mesh-${index}`,
+            primitives: []
+          };
+          if (gltfMesh.primitives) {
+            mesh.primitives = gltfMesh.primitives.map((gltfPrimitive) => {
+              const primitive = {
+                ...gltfPrimitive,
+                attributes: {},
+                indices: void 0,
+                material: void 0
+              };
+              const attributes = gltfPrimitive.attributes;
+              for (const attribute in attributes) {
+                primitive.attributes[attribute] = this.getAccessor(attributes[attribute]);
+              }
+              if (gltfPrimitive.indices !== void 0) {
+                primitive.indices = this.getAccessor(gltfPrimitive.indices);
+              }
+              if (gltfPrimitive.material !== void 0) {
+                primitive.material = this.getMaterial(gltfPrimitive.material);
+              }
+              return primitive;
+            });
+          }
+          return mesh;
+        }
+        _resolveMaterial(gltfMaterial, index) {
+          const material = {
+            ...gltfMaterial,
+            id: gltfMaterial.id || `material-${index}`
+          };
+          if (material.normalTexture) {
+            material.normalTexture = { ...material.normalTexture };
+            material.normalTexture.texture = this.getTexture(material.normalTexture.index);
+          }
+          if (material.occlusionTexture) {
+            material.occlusionTexture = { ...material.occlusionTexture };
+            material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);
+          }
+          if (material.emissiveTexture) {
+            material.emissiveTexture = { ...material.emissiveTexture };
+            material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);
+          }
+          if (!material.emissiveFactor) {
+            material.emissiveFactor = material.emissiveTexture ? [1, 1, 1] : [0, 0, 0];
+          }
+          if (material.pbrMetallicRoughness) {
+            material.pbrMetallicRoughness = { ...material.pbrMetallicRoughness };
+            const mr = material.pbrMetallicRoughness;
+            if (mr.baseColorTexture) {
+              mr.baseColorTexture = { ...mr.baseColorTexture };
+              mr.baseColorTexture.texture = this.getTexture(mr.baseColorTexture.index);
+            }
+            if (mr.metallicRoughnessTexture) {
+              mr.metallicRoughnessTexture = { ...mr.metallicRoughnessTexture };
+              mr.metallicRoughnessTexture.texture = this.getTexture(mr.metallicRoughnessTexture.index);
+            }
+          }
+          return material;
+        }
+        _resolveAccessor(gltfAccessor, index) {
+          const bytesPerComponent = getBytesFromComponentType(gltfAccessor.componentType);
+          const components = getSizeFromAccessorType(gltfAccessor.type);
+          const bytesPerElement = bytesPerComponent * components;
+          const accessor = {
+            ...gltfAccessor,
+            id: gltfAccessor.id || `accessor-${index}`,
+            bytesPerComponent,
+            components,
+            bytesPerElement,
+            value: void 0,
+            bufferView: void 0,
+            sparse: void 0
+          };
+          if (gltfAccessor.bufferView !== void 0) {
+            accessor.bufferView = this.getBufferView(gltfAccessor.bufferView);
+          }
+          if (accessor.bufferView) {
+            const buffer = accessor.bufferView.buffer;
+            const { ArrayType, byteLength } = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);
+            const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
+            let cutBuffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
+            if (accessor.bufferView.byteStride) {
+              cutBuffer = this._getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
+            }
+            accessor.value = new ArrayType(cutBuffer);
+          }
+          return accessor;
+        }
+        _getValueFromInterleavedBuffer(buffer, byteOffset, byteStride, bytesPerElement, count) {
+          const result = new Uint8Array(count * bytesPerElement);
+          for (let i2 = 0; i2 < count; i2++) {
+            const elementOffset = byteOffset + i2 * byteStride;
+            result.set(new Uint8Array(buffer.arrayBuffer.slice(elementOffset, elementOffset + bytesPerElement)), i2 * bytesPerElement);
+          }
+          return result.buffer;
+        }
+        _resolveTexture(gltfTexture, index) {
+          return {
+            ...gltfTexture,
+            id: gltfTexture.id || `texture-${index}`,
+            sampler: typeof gltfTexture.sampler === "number" ? this.getSampler(gltfTexture.sampler) : makeDefaultSampler(),
+            source: typeof gltfTexture.source === "number" ? this.getImage(gltfTexture.source) : void 0
+          };
+        }
+        _resolveSampler(gltfSampler, index) {
+          const sampler = {
+            id: gltfSampler.id || `sampler-${index}`,
+            ...gltfSampler,
+            parameters: {}
+          };
+          for (const key in sampler) {
+            const glEnum = this._enumSamplerParameter(key);
+            if (glEnum !== void 0) {
+              sampler.parameters[glEnum] = sampler[key];
+            }
+          }
+          return sampler;
+        }
+        _enumSamplerParameter(key) {
+          return SAMPLER_PARAMETER_GLTF_TO_GL[key];
+        }
+        _resolveImage(gltfImage, index) {
+          const image = {
+            ...gltfImage,
+            id: gltfImage.id || `image-${index}`,
+            image: null,
+            bufferView: gltfImage.bufferView !== void 0 ? this.getBufferView(gltfImage.bufferView) : void 0
+          };
+          const preloadedImage = this.images[index];
+          if (preloadedImage) {
+            image.image = preloadedImage;
+          }
+          return image;
+        }
+        _resolveBufferView(gltfBufferView, index) {
+          const bufferIndex = gltfBufferView.buffer;
+          const arrayBuffer = this.buffers[bufferIndex].arrayBuffer;
+          let byteOffset = this.buffers[bufferIndex].byteOffset || 0;
+          if (gltfBufferView.byteOffset) {
+            byteOffset += gltfBufferView.byteOffset;
+          }
+          const bufferView = {
+            id: `bufferView-${index}`,
+            ...gltfBufferView,
+            buffer: this.buffers[bufferIndex],
+            data: new Uint8Array(arrayBuffer, byteOffset, gltfBufferView.byteLength)
+          };
+          return bufferView;
+        }
+        _resolveCamera(gltfCamera, index) {
+          const camera = {
+            ...gltfCamera,
+            id: gltfCamera.id || `camera-${index}`
+          };
+          if (camera.perspective) {
+          }
+          if (camera.orthographic) {
+          }
+          return camera;
+        }
+      };
+    }
+  });
+
   // src/index.ts
   var src_exports = {};
   __export(src_exports, {
@@ -5540,6 +5740,7 @@
     GLTFLoader: () => GLTFLoader,
     GLTFScenegraph: () => GLTFScenegraph,
     GLTFWriter: () => GLTFWriter,
+    _getMemoryUsageGLTF: () => getMemoryUsageGLTF,
     postProcessGLTF: () => postProcessGLTF
   });
   var init_src7 = __esm({
@@ -5550,6 +5751,7 @@
       init_glb_writer();
       init_gltf_scenegraph();
       init_post_process_gltf();
+      init_gltf_utils();
     }
   });