@deck.gl/geo-layers 9.3.0-alpha.1 → 9.3.0-alpha.2

package/dist/dist.dev.js

@@ -10208,7 +10208,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/xml/dist/xml-loader.js
-  var VERSION = true ? "4.4.0-alpha.16" : "latest";
+  var VERSION = true ? "4.4.0-alpha.18" : "latest";
   var XMLLoader = {
     dataType: null,
     batchType: null,
@@ -10269,14 +10269,14 @@ var __exports__ = (() => {
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
-  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/globals.js
+  // ../../node_modules/@probe.gl/env/dist/lib/globals.js
   var window_2 = globalThis;
   var document_2 = globalThis.document || {};
   var process_ = globalThis.process || {};
   var console_ = globalThis.console;
   var navigator_ = globalThis.navigator || {};
 
-  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-electron.js
+  // ../../node_modules/@probe.gl/env/dist/lib/is-electron.js
   function isElectron(mockUserAgent) {
     if (typeof window !== "undefined" && window.process?.type === "renderer") {
       return true;
@@ -10289,7 +10289,7 @@ var __exports__ = (() => {
     return Boolean(userAgent && userAgent.indexOf("Electron") >= 0);
   }
 
-  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-browser.js
+  // ../../node_modules/@probe.gl/env/dist/lib/is-browser.js
   function isBrowser2() {
     const isNode = (
       // @ts-expect-error
@@ -10298,7 +10298,7 @@ var __exports__ = (() => {
     return !isNode || isElectron();
   }
 
-  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/index.js
+  // ../../node_modules/@probe.gl/env/dist/index.js
   var VERSION2 = true ? "4.1.1" : "untranspiled source";
 
   // ../../node_modules/@probe.gl/log/dist/utils/assert.js
@@ -10791,7 +10791,7 @@ var __exports__ = (() => {
   var dist_default = new ProbeLog({ id: "@probe.gl/log" });
 
   // ../../node_modules/@loaders.gl/loader-utils/dist/lib/log-utils/log.js
-  var VERSION3 = true ? "4.4.0-alpha.16" : "latest";
+  var VERSION3 = true ? "4.4.0-alpha.18" : "latest";
   var version = VERSION3[0] >= "0" && VERSION3[0] <= "9" ? `v${VERSION3}` : "";
   function createLog() {
     const log8 = new ProbeLog({ id: "loaders.gl" });
@@ -10846,7 +10846,7 @@ var __exports__ = (() => {
         globalThis._loadersgl_.version = NPM_TAG;
         warningIssued = true;
       } else {
-        globalThis._loadersgl_.version = "4.4.0-alpha.16";
+        globalThis._loadersgl_.version = "4.4.0-alpha.18";
       }
     }
     return globalThis._loadersgl_.version;
@@ -10882,6 +10882,16 @@ var __exports__ = (() => {
 
   // ../../node_modules/@loaders.gl/worker-utils/dist/lib/library-utils/library-utils.js
   var loadLibraryPromises = {};
+  function extractLoadLibraryOptions(options = {}) {
+    const useLocalLibraries = options.useLocalLibraries ?? options.core?.useLocalLibraries;
+    const CDN = options.CDN ?? options.core?.CDN;
+    const modules = options.modules;
+    return {
+      ...useLocalLibraries !== void 0 ? { useLocalLibraries } : {},
+      ...CDN !== void 0 ? { CDN } : {},
+      ...modules !== void 0 ? { modules } : {}
+    };
+  }
   async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
     if (moduleName) {
       libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
@@ -11067,7 +11077,7 @@ var __exports__ = (() => {
     return targetOffset + padToNBytes(sourceArray.byteLength, 4);
   }
 
-  // ../../node_modules/@loaders.gl/loader-utils/node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
+  // ../../node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
   function getHiResTimestamp2() {
     let timestamp;
     if (typeof window !== "undefined" && window.performance) {
@@ -11081,7 +11091,7 @@ var __exports__ = (() => {
     return timestamp;
   }
 
-  // ../../node_modules/@loaders.gl/loader-utils/node_modules/@probe.gl/stats/dist/lib/stat.js
+  // ../../node_modules/@probe.gl/stats/dist/lib/stat.js
   var Stat = class {
     constructor(name12, type) {
       this.sampleSize = 1;
@@ -11202,7 +11212,7 @@ var __exports__ = (() => {
     }
   };
 
-  // ../../node_modules/@loaders.gl/loader-utils/node_modules/@probe.gl/stats/dist/lib/stats.js
+  // ../../node_modules/@probe.gl/stats/dist/lib/stats.js
   var Stats = class {
     constructor(options) {
       this.stats = {};
@@ -11665,7 +11675,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/wms/dist/wms-error-loader.js
-  var VERSION5 = true ? "4.4.0-alpha.16" : "latest";
+  var VERSION5 = true ? "4.4.0-alpha.18" : "latest";
   var WMSErrorLoader = {
     dataType: null,
     batchType: null,
@@ -11944,7 +11954,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/wms/dist/wms-capabilities-loader.js
-  var VERSION6 = true ? "4.4.0-alpha.16" : "latest";
+  var VERSION6 = true ? "4.4.0-alpha.18" : "latest";
   var WMSCapabilitiesLoader = {
     dataType: null,
     batchType: null,
@@ -12017,7 +12027,7 @@ var __exports__ = (() => {
   };
 
   // ../../node_modules/@loaders.gl/images/dist/lib/utils/version.js
-  var VERSION7 = true ? "4.4.0-alpha.16" : "latest";
+  var VERSION7 = true ? "4.4.0-alpha.18" : "latest";
 
   // ../../node_modules/@loaders.gl/images/dist/lib/category-api/image-type.js
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -15502,213 +15512,884 @@ out float vTime;
   var import_layers8 = __toESM(require_layers(), 1);
   var import_mesh_layers2 = __toESM(require_mesh_layers(), 1);
 
-  // ../../node_modules/@luma.gl/gltf/dist/parsers/parse-pbr-material.js
-  var import_core20 = __toESM(require_core3(), 1);
+  // ../../node_modules/@loaders.gl/textures/dist/lib/utils/version.js
+  var VERSION8 = true ? "4.4.0-alpha.18" : "latest";
 
-  // ../../node_modules/@luma.gl/gltf/dist/webgl-to-webgpu/convert-webgl-sampler.js
-  function convertSampler(gltfSampler) {
-    return {
-      addressModeU: convertSamplerWrapMode(gltfSampler.wrapS),
-      addressModeV: convertSamplerWrapMode(gltfSampler.wrapT),
-      magFilter: convertSamplerMagFilter(gltfSampler.magFilter),
-      ...convertSamplerMinFilter(gltfSampler.minFilter)
-    };
-  }
-  function convertSamplerWrapMode(mode) {
-    switch (mode) {
-      case 33071:
-        return "clamp-to-edge";
-      case 10497:
-        return "repeat";
-      case 33648:
-        return "mirror-repeat";
-      default:
-        return void 0;
-    }
-  }
-  function convertSamplerMagFilter(mode) {
-    switch (mode) {
-      case 9728:
-        return "nearest";
-      case 9729:
-        return "linear";
-      default:
-        return void 0;
+  // ../../node_modules/@loaders.gl/textures/dist/lib/parsers/basis-module-loader.js
+  var BASIS_EXTERNAL_LIBRARIES = {
+    /** Basis transcoder, javascript wrapper part */
+    TRANSCODER: "basis_transcoder.js",
+    /** Basis transcoder, compiled web assembly part */
+    TRANSCODER_WASM: "basis_transcoder.wasm",
+    /** Basis encoder, javascript wrapper part */
+    ENCODER: "basis_encoder.js",
+    /** Basis encoder, compiled web assembly part */
+    ENCODER_WASM: "basis_encoder.wasm"
+  };
+  var loadBasisTranscoderPromise;
+  async function loadBasisTranscoderModule(options) {
+    registerJSModules(options.modules);
+    const basis = getJSModuleOrNull("basis");
+    if (basis) {
+      return basis;
     }
+    loadBasisTranscoderPromise ||= loadBasisTranscoder(options);
+    return await loadBasisTranscoderPromise;
   }
-  function convertSamplerMinFilter(mode) {
-    switch (mode) {
-      case 9728:
-        return { minFilter: "nearest" };
-      case 9729:
-        return { minFilter: "linear" };
-      case 9984:
-        return { minFilter: "nearest", mipmapFilter: "nearest" };
-      case 9985:
-        return { minFilter: "linear", mipmapFilter: "nearest" };
-      case 9986:
-        return { minFilter: "nearest", mipmapFilter: "linear" };
-      case 9987:
-        return { minFilter: "linear", mipmapFilter: "linear" };
-      default:
-        return {};
-    }
+  async function loadBasisTranscoder(options) {
+    let BASIS2 = null;
+    let wasmBinary = null;
+    [BASIS2, wasmBinary] = await Promise.all([
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER, "textures", options),
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER_WASM, "textures", options)
+    ]);
+    BASIS2 = BASIS2 || globalThis.BASIS;
+    return await initializeBasisTranscoderModule(BASIS2, wasmBinary);
   }
-
-  // ../../node_modules/@luma.gl/gltf/dist/parsers/parse-pbr-material.js
-  function parsePBRMaterial(device, material, attributes, options) {
-    const parsedMaterial = {
-      defines: {
-        // TODO: Use EXT_sRGB if available (Standard in WebGL 2.0)
-        MANUAL_SRGB: true,
-        SRGB_FAST_APPROXIMATION: true
-      },
-      bindings: {},
-      uniforms: {
-        // TODO: find better values?
-        camera: [0, 0, 0],
-        // Model should override
-        metallicRoughnessValues: [1, 1]
-        // Default is 1 and 1
-      },
-      parameters: {},
-      glParameters: {},
-      generatedTextures: []
-    };
-    parsedMaterial.defines["USE_TEX_LOD"] = true;
-    const { imageBasedLightingEnvironment } = options;
-    if (imageBasedLightingEnvironment) {
-      parsedMaterial.bindings.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler.texture;
-      parsedMaterial.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler.texture;
-      parsedMaterial.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
-      parsedMaterial.uniforms.scaleIBLAmbient = [1, 1];
-    }
-    if (options?.pbrDebug) {
-      parsedMaterial.defines["PBR_DEBUG"] = true;
-      parsedMaterial.uniforms.scaleDiffBaseMR = [0, 0, 0, 0];
-      parsedMaterial.uniforms.scaleFGDSpec = [0, 0, 0, 0];
-    }
-    if (attributes["NORMAL"])
-      parsedMaterial.defines["HAS_NORMALS"] = true;
-    if (attributes["TANGENT"] && options?.useTangents)
-      parsedMaterial.defines["HAS_TANGENTS"] = true;
-    if (attributes["TEXCOORD_0"])
-      parsedMaterial.defines["HAS_UV"] = true;
-    if (options?.imageBasedLightingEnvironment)
-      parsedMaterial.defines["USE_IBL"] = true;
-    if (options?.lights)
-      parsedMaterial.defines["USE_LIGHTS"] = true;
-    if (material) {
-      parseMaterial(device, material, parsedMaterial);
+  function initializeBasisTranscoderModule(BasisModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
     }
-    return parsedMaterial;
+    return new Promise((resolve2) => {
+      BasisModule(options).then((module) => {
+        const { BasisFile, initializeBasis } = module;
+        initializeBasis();
+        resolve2({ BasisFile });
+      });
+    });
   }
-  function parseMaterial(device, material, parsedMaterial) {
-    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
-    if (material.pbrMetallicRoughness) {
-      parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
-    }
-    if (material.normalTexture) {
-      addTexture(device, material.normalTexture, "pbr_normalSampler", "HAS_NORMALMAP", parsedMaterial);
-      const { scale: scale12 = 1 } = material.normalTexture;
-      parsedMaterial.uniforms.normalScale = scale12;
-    }
-    if (material.occlusionTexture) {
-      addTexture(device, material.occlusionTexture, "pbr_occlusionSampler", "HAS_OCCLUSIONMAP", parsedMaterial);
-      const { strength = 1 } = material.occlusionTexture;
-      parsedMaterial.uniforms.occlusionStrength = strength;
-    }
-    if (material.emissiveTexture) {
-      addTexture(device, material.emissiveTexture, "pbr_emissiveSampler", "HAS_EMISSIVEMAP", parsedMaterial);
-      parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
-    }
-    switch (material.alphaMode || "MASK") {
-      case "MASK":
-        const { alphaCutoff = 0.5 } = material;
-        parsedMaterial.defines["ALPHA_CUTOFF"] = true;
-        parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
-        break;
-      case "BLEND":
-        import_core20.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
-        parsedMaterial.parameters.blend = true;
-        parsedMaterial.parameters.blendColorOperation = "add";
-        parsedMaterial.parameters.blendColorSrcFactor = "src-alpha";
-        parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
-        parsedMaterial.parameters.blendAlphaOperation = "add";
-        parsedMaterial.parameters.blendAlphaSrcFactor = "one";
-        parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
-        parsedMaterial.glParameters["blend"] = true;
-        parsedMaterial.glParameters["blendEquation"] = 32774;
-        parsedMaterial.glParameters["blendFunc"] = [
-          770,
-          771,
-          1,
-          771
-        ];
-        break;
+  var loadBasisEncoderPromise;
+  async function loadBasisEncoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basisEncoder) {
+      return modules.basisEncoder;
     }
+    loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
+    return await loadBasisEncoderPromise;
   }
-  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial) {
-    if (pbrMetallicRoughness.baseColorTexture) {
-      addTexture(device, pbrMetallicRoughness.baseColorTexture, "pbr_baseColorSampler", "HAS_BASECOLORMAP", parsedMaterial);
-    }
-    parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
-    if (pbrMetallicRoughness.metallicRoughnessTexture) {
-      addTexture(device, pbrMetallicRoughness.metallicRoughnessTexture, "pbr_metallicRoughnessSampler", "HAS_METALROUGHNESSMAP", parsedMaterial);
-    }
-    const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
-    parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
+  async function loadBasisEncoder(options) {
+    let BASIS_ENCODER = null;
+    let wasmBinary = null;
+    [BASIS_ENCODER, wasmBinary] = await Promise.all([
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER, "textures", options),
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER_WASM, "textures", options)
+    ]);
+    BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
+    return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
   }
-  function addTexture(device, gltfTexture, uniformName, define2, parsedMaterial) {
-    const image = gltfTexture.texture.source.image;
-    let textureOptions;
-    if (image.compressed) {
-      textureOptions = image;
-    } else {
-      textureOptions = { data: image };
+  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
     }
-    const gltfSampler = {
-      wrapS: 10497,
-      // default REPEAT S (U) wrapping mode.
-      wrapT: 10497,
-      // default REPEAT T (V) wrapping mode.
-      ...gltfTexture?.texture?.sampler
-    };
-    const texture = device.createTexture({
-      id: gltfTexture.uniformName || gltfTexture.id,
-      sampler: convertSampler(gltfSampler),
-      ...textureOptions
+    return new Promise((resolve2) => {
+      BasisEncoderModule(options).then((module) => {
+        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
+        initializeBasis();
+        resolve2({ BasisFile, KTX2File, BasisEncoder });
+      });
     });
-    parsedMaterial.bindings[uniformName] = texture;
-    if (define2)
-      parsedMaterial.defines[define2] = true;
-    parsedMaterial.generatedTextures.push(texture);
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting.js
-  var import_core21 = __toESM(require_core3(), 1);
-
-  // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting-glsl.js
-  var lightingUniformsGLSL = (
-    /* glsl */
-    `precision highp int;
-
-// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
-struct AmbientLight {
-  vec3 color;
-};
-
-struct PointLight {
-  vec3 color;
-  vec3 position;
-  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
-};
-
-struct DirectionalLight {
-  vec3 color;
-  vec3 direction;
-};
-
+  // ../../node_modules/@loaders.gl/textures/dist/lib/gl-extensions.js
+  var GL_RGBA4 = 32854;
+  var GL_RGBA8 = 32856;
+  var GL_RGB565 = 36194;
+  var GL_COMPRESSED_RGB_S3TC_DXT1_EXT = 33776;
+  var GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 33779;
+  var GL_COMPRESSED_RGBA8_ETC2_EAC = 37493;
+  var GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 35840;
+  var GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 35842;
+  var GL_COMPRESSED_RGB_ETC1_WEBGL = 36196;
+  var GL_COMPRESSED_RGB_ATC_WEBGL = 35986;
+  var GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL = 34798;
+  var GL_COMPRESSED_RGBA_ASTC_4x4_KHR = 37808;
+  var GL_COMPRESSED_RED_RGTC1_EXT = 36283;
+  var GL_COMPRESSED_RED_GREEN_RGTC2_EXT = 36285;
+  var GL_COMPRESSED_RGBA_BPTC_UNORM_EXT = 36492;
+
+  // ../../node_modules/@loaders.gl/textures/dist/lib/utils/detect-supported-texture-formats.js
+  var BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
+  var WEBGL_TEXTURE_FORMATS = {
+    /* eslint-disable camelcase */
+    WEBGL_compressed_texture_s3tc: [
+      "bc1-rgb-unorm-webgl",
+      "bc1-rgba-unorm",
+      "bc2-rgba-unorm",
+      "bc3-rgba-unorm"
+    ],
+    WEBGL_compressed_texture_s3tc_srgb: [
+      "bc1-rgb-unorm-srgb-webgl",
+      "bc1-rgba-unorm-srgb",
+      "bc2-rgba-unorm-srgb",
+      "bc3-rgba-unorm-srgb"
+    ],
+    EXT_texture_compression_rgtc: ["bc4-r-unorm", "bc4-r-snorm", "bc5-rg-unorm", "bc5-rg-snorm"],
+    EXT_texture_compression_bptc: [
+      "bc6h-rgb-ufloat",
+      "bc6h-rgb-float",
+      "bc7-rgba-unorm",
+      "bc7-rgba-unorm-srgb"
+    ],
+    WEBGL_compressed_texture_etc1: ["etc1-rbg-unorm-webgl"],
+    WEBGL_compressed_texture_etc: [
+      "etc2-rgb8unorm",
+      "etc2-rgb8unorm-srgb",
+      "etc2-rgb8a1unorm",
+      "etc2-rgb8a1unorm-srgb",
+      "etc2-rgba8unorm",
+      "etc2-rgba8unorm-srgb",
+      "eac-r11unorm",
+      "eac-r11snorm",
+      "eac-rg11unorm",
+      "eac-rg11snorm"
+    ],
+    WEBGL_compressed_texture_pvrtc: [
+      "pvrtc-rgb4unorm-webgl",
+      "pvrtc-rgba4unorm-webgl",
+      "pvrtc-rbg2unorm-webgl",
+      "pvrtc-rgba2unorm-webgl"
+    ],
+    WEBGL_compressed_texture_atc: [
+      "atc-rgb-unorm-webgl",
+      "atc-rgba-unorm-webgl",
+      "atc-rgbai-unorm-webgl"
+    ],
+    WEBGL_compressed_texture_astc: [
+      "astc-4x4-unorm",
+      "astc-4x4-unorm-srgb",
+      "astc-5x4-unorm",
+      "astc-5x4-unorm-srgb",
+      "astc-5x5-unorm",
+      "astc-5x5-unorm-srgb",
+      "astc-6x5-unorm",
+      "astc-6x5-unorm-srgb",
+      "astc-6x6-unorm",
+      "astc-6x6-unorm-srgb",
+      "astc-8x5-unorm",
+      "astc-8x5-unorm-srgb",
+      "astc-8x6-unorm",
+      "astc-8x6-unorm-srgb",
+      "astc-8x8-unorm",
+      "astc-8x8-unorm-srgb",
+      "astc-10x5-unorm",
+      "astc-10x5-unorm-srgb",
+      "astc-10x6-unorm",
+      "astc-10x6-unorm-srgb",
+      "astc-10x8-unorm",
+      "astc-10x8-unorm-srgb",
+      "astc-10x10-unorm",
+      "astc-10x10-unorm-srgb",
+      "astc-12x10-unorm",
+      "astc-12x10-unorm-srgb",
+      "astc-12x12-unorm",
+      "astc-12x12-unorm-srgb"
+    ]
+    /* eslint-enable camelcase */
+  };
+  var textureFormats = null;
+  function detectSupportedTextureFormats(gl) {
+    if (!textureFormats) {
+      gl = gl || getWebGLContext() || void 0;
+      textureFormats = /* @__PURE__ */ new Set();
+      for (const prefix of BROWSER_PREFIXES) {
+        for (const extension in WEBGL_TEXTURE_FORMATS) {
+          if (gl && gl.getExtension(`${prefix}${extension}`)) {
+            for (const textureFormat of WEBGL_TEXTURE_FORMATS[extension]) {
+              textureFormats.add(textureFormat);
+            }
+          }
+        }
+      }
+    }
+    return textureFormats;
+  }
+  function getWebGLContext() {
+    try {
+      const canvas = document.createElement("canvas");
+      return canvas.getContext("webgl");
+    } catch (error) {
+      return null;
+    }
+  }
+
+  // ../../node_modules/@loaders.gl/textures/dist/lib/parsers/parse-ktx.js
+  var KTX2_ID = [
+    // '´', 'K', 'T', 'X', '2', '0', 'ª', '\r', '\n', '\x1A', '\n'
+    171,
+    75,
+    84,
+    88,
+    32,
+    50,
+    48,
+    187,
+    13,
+    10,
+    26,
+    10
+  ];
+  function isKTX(data) {
+    const id = new Uint8Array(data);
+    const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || // '´'
+    id[1] !== KTX2_ID[1] || // 'K'
+    id[2] !== KTX2_ID[2] || // 'T'
+    id[3] !== KTX2_ID[3] || // 'X'
+    id[4] !== KTX2_ID[4] || // ' '
+    id[5] !== KTX2_ID[5] || // '2'
+    id[6] !== KTX2_ID[6] || // '0'
+    id[7] !== KTX2_ID[7] || // 'ª'
+    id[8] !== KTX2_ID[8] || // '\r'
+    id[9] !== KTX2_ID[9] || // '\n'
+    id[10] !== KTX2_ID[10] || // '\x1A'
+    id[11] !== KTX2_ID[11];
+    return !notKTX;
+  }
+
+  // ../../node_modules/@loaders.gl/textures/dist/lib/parsers/parse-basis.js
+  var BASIS_FORMAT_TO_OUTPUT_OPTIONS = {
+    etc1: {
+      basisFormat: 0,
+      compressed: true,
+      format: GL_COMPRESSED_RGB_ETC1_WEBGL,
+      textureFormat: "etc1-rbg-unorm-webgl"
+    },
+    etc2: {
+      basisFormat: 1,
+      compressed: true,
+      format: GL_COMPRESSED_RGBA8_ETC2_EAC,
+      textureFormat: "etc2-rgba8unorm"
+    },
+    bc1: {
+      basisFormat: 2,
+      compressed: true,
+      format: GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
+      textureFormat: "bc1-rgb-unorm-webgl"
+    },
+    bc3: {
+      basisFormat: 3,
+      compressed: true,
+      format: GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
+      textureFormat: "bc3-rgba-unorm"
+    },
+    bc4: {
+      basisFormat: 4,
+      compressed: true,
+      format: GL_COMPRESSED_RED_RGTC1_EXT,
+      textureFormat: "bc4-r-unorm"
+    },
+    bc5: {
+      basisFormat: 5,
+      compressed: true,
+      format: GL_COMPRESSED_RED_GREEN_RGTC2_EXT,
+      textureFormat: "bc5-rg-unorm"
+    },
+    "bc7-m6-opaque-only": {
+      basisFormat: 6,
+      compressed: true,
+      format: GL_COMPRESSED_RGBA_BPTC_UNORM_EXT,
+      textureFormat: "bc7-rgba-unorm"
+    },
+    "bc7-m5": {
+      basisFormat: 7,
+      compressed: true,
+      format: GL_COMPRESSED_RGBA_BPTC_UNORM_EXT,
+      textureFormat: "bc7-rgba-unorm"
+    },
+    "pvrtc1-4-rgb": {
+      basisFormat: 8,
+      compressed: true,
+      format: GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG,
+      textureFormat: "pvrtc-rgb4unorm-webgl"
+    },
+    "pvrtc1-4-rgba": {
+      basisFormat: 9,
+      compressed: true,
+      format: GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
+      textureFormat: "pvrtc-rgba4unorm-webgl"
+    },
+    "astc-4x4": {
+      basisFormat: 10,
+      compressed: true,
+      format: GL_COMPRESSED_RGBA_ASTC_4x4_KHR,
+      textureFormat: "astc-4x4-unorm"
+    },
+    "atc-rgb": {
+      basisFormat: 11,
+      compressed: true,
+      format: GL_COMPRESSED_RGB_ATC_WEBGL,
+      textureFormat: "atc-rgb-unorm-webgl"
+    },
+    "atc-rgba-interpolated-alpha": {
+      basisFormat: 12,
+      compressed: true,
+      format: GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL,
+      textureFormat: "atc-rgbai-unorm-webgl"
+    },
+    rgba32: {
+      basisFormat: 13,
+      compressed: false,
+      format: GL_RGBA8,
+      textureFormat: "rgba8unorm"
+    },
+    rgb565: {
+      basisFormat: 14,
+      compressed: false,
+      format: GL_RGB565,
+      textureFormat: "rgb565unorm-webgl"
+    },
+    bgr565: {
+      basisFormat: 15,
+      compressed: false,
+      format: GL_RGB565,
+      textureFormat: "rgb565unorm-webgl"
+    },
+    rgba4444: {
+      basisFormat: 16,
+      compressed: false,
+      format: GL_RGBA4,
+      textureFormat: "rgba4unorm-webgl"
+    }
+  };
+  var BASIS_FORMATS = Object.freeze(Object.keys(BASIS_FORMAT_TO_OUTPUT_OPTIONS));
+  async function parseBasis(data, options = {}) {
+    const loadLibraryOptions = extractLoadLibraryOptions(options);
+    if (!options.basis?.containerFormat || options.basis.containerFormat === "auto") {
+      if (isKTX(data)) {
+        const fileConstructors = await loadBasisEncoderModule(loadLibraryOptions);
+        return parseKTX2File(fileConstructors.KTX2File, data, options);
+      }
+      const { BasisFile } = await loadBasisTranscoderModule(loadLibraryOptions);
+      return parseBasisFile(BasisFile, data, options);
+    }
+    switch (options.basis.module) {
+      case "encoder":
+        const fileConstructors = await loadBasisEncoderModule(loadLibraryOptions);
+        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 loadBasisTranscoderModule(loadLibraryOptions);
+        return parseBasisFile(BasisFile, data, options);
+    }
+  }
+  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));
+        }
+        images.push(levels);
+      }
+      return images;
+    } finally {
+      basisFile.close();
+      basisFile.delete();
+    }
+  }
+  function transcodeImage(basisFile, imageIndex, levelIndex, options) {
+    const width = basisFile.getImageWidth(imageIndex, levelIndex);
+    const height = basisFile.getImageHeight(imageIndex, levelIndex);
+    const hasAlpha = basisFile.getHasAlpha(
+      /* imageIndex, levelIndex */
+    );
+    const { compressed, format, basisFormat, textureFormat } = getBasisOptions(options, hasAlpha);
+    const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
+    const decodedData = new Uint8Array(decodedSize);
+    if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
+      throw new Error("failed to start Basis transcoding");
+    }
+    return {
+      // standard loaders.gl image category payload
+      shape: "texture-level",
+      width,
+      height,
+      data: decodedData,
+      compressed,
+      ...format !== void 0 ? { format } : {},
+      ...textureFormat !== void 0 ? { textureFormat } : {},
+      // Additional fields
+      // Add levelSize field.
+      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");
+      }
+      const levelsCount = ktx2File.getLevels();
+      const levels = [];
+      for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
+        levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
+      }
+      return [levels];
+    } finally {
+      ktx2File.close();
+      ktx2File.delete();
+    }
+  }
+  function transcodeKTX2Image(ktx2File, levelIndex, options) {
+    const { alphaFlag, height, width } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
+    const { compressed, format, basisFormat, textureFormat } = 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
+      /* channel1 */
+    )) {
+      throw new Error("Failed to transcode KTX2 image");
+    }
+    return {
+      // standard loaders.gl image category payload
+      shape: "texture-level",
+      width,
+      height,
+      data: decodedData,
+      compressed,
+      ...format !== void 0 ? { format } : {},
+      ...textureFormat !== void 0 ? { textureFormat } : {},
+      // Additional fields
+      levelSize: decodedSize,
+      hasAlpha: alphaFlag
+    };
+  }
+  function getBasisOptions(options, hasAlpha) {
+    let format = options.basis?.format || "auto";
+    if (format === "auto") {
+      format = options.basis?.supportedTextureFormats ? selectSupportedBasisFormat(options.basis.supportedTextureFormats) : selectSupportedBasisFormat();
+    }
+    if (typeof format === "object") {
+      format = hasAlpha ? format.alpha : format.noAlpha;
+    }
+    const normalizedFormat = format.toLowerCase();
+    const basisOutputOptions = BASIS_FORMAT_TO_OUTPUT_OPTIONS[normalizedFormat];
+    if (!basisOutputOptions) {
+      throw new Error(`Unknown Basis format ${format}`);
+    }
+    return basisOutputOptions;
+  }
+  function selectSupportedBasisFormat(supportedTextureFormats = detectSupportedTextureFormats()) {
+    const textureFormats2 = new Set(supportedTextureFormats);
+    if (hasSupportedTextureFormat(textureFormats2, ["astc-4x4-unorm", "astc-4x4-unorm-srgb"])) {
+      return "astc-4x4";
+    } else if (hasSupportedTextureFormat(textureFormats2, ["bc7-rgba-unorm", "bc7-rgba-unorm-srgb"])) {
+      return {
+        alpha: "bc7-m5",
+        noAlpha: "bc7-m6-opaque-only"
+      };
+    } else if (hasSupportedTextureFormat(textureFormats2, [
+      "bc1-rgb-unorm-webgl",
+      "bc1-rgb-unorm-srgb-webgl",
+      "bc1-rgba-unorm",
+      "bc1-rgba-unorm-srgb",
+      "bc2-rgba-unorm",
+      "bc2-rgba-unorm-srgb",
+      "bc3-rgba-unorm",
+      "bc3-rgba-unorm-srgb"
+    ])) {
+      return {
+        alpha: "bc3",
+        noAlpha: "bc1"
+      };
+    } else if (hasSupportedTextureFormat(textureFormats2, [
+      "pvrtc-rgb4unorm-webgl",
+      "pvrtc-rgba4unorm-webgl",
+      "pvrtc-rbg2unorm-webgl",
+      "pvrtc-rgba2unorm-webgl"
+    ])) {
+      return {
+        alpha: "pvrtc1-4-rgba",
+        noAlpha: "pvrtc1-4-rgb"
+      };
+    } else if (hasSupportedTextureFormat(textureFormats2, [
+      "etc2-rgb8unorm",
+      "etc2-rgb8unorm-srgb",
+      "etc2-rgb8a1unorm",
+      "etc2-rgb8a1unorm-srgb",
+      "etc2-rgba8unorm",
+      "etc2-rgba8unorm-srgb",
+      "eac-r11unorm",
+      "eac-r11snorm",
+      "eac-rg11unorm",
+      "eac-rg11snorm"
+    ])) {
+      return "etc2";
+    } else if (textureFormats2.has("etc1-rbg-unorm-webgl")) {
+      return "etc1";
+    } else if (hasSupportedTextureFormat(textureFormats2, [
+      "atc-rgb-unorm-webgl",
+      "atc-rgba-unorm-webgl",
+      "atc-rgbai-unorm-webgl"
+    ])) {
+      return {
+        alpha: "atc-rgba-interpolated-alpha",
+        noAlpha: "atc-rgb"
+      };
+    }
+    return "rgb565";
+  }
+  function hasSupportedTextureFormat(supportedTextureFormats, candidateTextureFormats) {
+    return candidateTextureFormats.some((textureFormat) => supportedTextureFormats.has(textureFormat));
+  }
+
+  // ../../node_modules/@loaders.gl/textures/dist/basis-loader.js
+  var BasisWorkerLoader = {
+    dataType: null,
+    batchType: null,
+    name: "Basis",
+    id: "basis",
+    module: "textures",
+    version: VERSION8,
+    worker: true,
+    extensions: ["basis", "ktx2"],
+    mimeTypes: ["application/octet-stream", "image/ktx2"],
+    tests: ["sB"],
+    binary: true,
+    options: {
+      basis: {
+        format: "auto",
+        containerFormat: "auto",
+        module: "transcoder"
+      }
+    }
+  };
+  var BasisLoader = {
+    ...BasisWorkerLoader,
+    parse: parseBasis
+  };
+
+  // ../../node_modules/@luma.gl/gltf/dist/parsers/parse-pbr-material.js
+  var import_core20 = __toESM(require_core3(), 1);
+
+  // ../../node_modules/@luma.gl/gltf/dist/webgl-to-webgpu/convert-webgl-sampler.js
+  function convertSampler(gltfSampler) {
+    return {
+      addressModeU: convertSamplerWrapMode(gltfSampler.wrapS),
+      addressModeV: convertSamplerWrapMode(gltfSampler.wrapT),
+      magFilter: convertSamplerMagFilter(gltfSampler.magFilter),
+      ...convertSamplerMinFilter(gltfSampler.minFilter)
+    };
+  }
+  function convertSamplerWrapMode(mode) {
+    switch (mode) {
+      case 33071:
+        return "clamp-to-edge";
+      case 10497:
+        return "repeat";
+      case 33648:
+        return "mirror-repeat";
+      default:
+        return void 0;
+    }
+  }
+  function convertSamplerMagFilter(mode) {
+    switch (mode) {
+      case 9728:
+        return "nearest";
+      case 9729:
+        return "linear";
+      default:
+        return void 0;
+    }
+  }
+  function convertSamplerMinFilter(mode) {
+    switch (mode) {
+      case 9728:
+        return { minFilter: "nearest" };
+      case 9729:
+        return { minFilter: "linear" };
+      case 9984:
+        return { minFilter: "nearest", mipmapFilter: "nearest" };
+      case 9985:
+        return { minFilter: "linear", mipmapFilter: "nearest" };
+      case 9986:
+        return { minFilter: "nearest", mipmapFilter: "linear" };
+      case 9987:
+        return { minFilter: "linear", mipmapFilter: "linear" };
+      default:
+        return {};
+    }
+  }
+
+  // ../../node_modules/@luma.gl/gltf/dist/parsers/parse-pbr-material.js
+  function parsePBRMaterial(device, material, attributes, options) {
+    const parsedMaterial = {
+      defines: {
+        // TODO: Use EXT_sRGB if available (Standard in WebGL 2.0)
+        MANUAL_SRGB: true,
+        SRGB_FAST_APPROXIMATION: true
+      },
+      bindings: {},
+      uniforms: {
+        // TODO: find better values?
+        camera: [0, 0, 0],
+        // Model should override
+        metallicRoughnessValues: [1, 1]
+        // Default is 1 and 1
+      },
+      parameters: {},
+      glParameters: {},
+      generatedTextures: []
+    };
+    parsedMaterial.defines["USE_TEX_LOD"] = true;
+    const { imageBasedLightingEnvironment } = options;
+    if (imageBasedLightingEnvironment) {
+      parsedMaterial.bindings.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler.texture;
+      parsedMaterial.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler.texture;
+      parsedMaterial.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
+      parsedMaterial.uniforms.scaleIBLAmbient = [1, 1];
+    }
+    if (options?.pbrDebug) {
+      parsedMaterial.defines["PBR_DEBUG"] = true;
+      parsedMaterial.uniforms.scaleDiffBaseMR = [0, 0, 0, 0];
+      parsedMaterial.uniforms.scaleFGDSpec = [0, 0, 0, 0];
+    }
+    if (attributes["NORMAL"])
+      parsedMaterial.defines["HAS_NORMALS"] = true;
+    if (attributes["TANGENT"] && options?.useTangents)
+      parsedMaterial.defines["HAS_TANGENTS"] = true;
+    if (attributes["TEXCOORD_0"])
+      parsedMaterial.defines["HAS_UV"] = true;
+    if (attributes["JOINTS_0"] && attributes["WEIGHTS_0"])
+      parsedMaterial.defines["HAS_SKIN"] = true;
+    if (attributes["COLOR_0"])
+      parsedMaterial.defines["HAS_COLORS"] = true;
+    if (options?.imageBasedLightingEnvironment)
+      parsedMaterial.defines["USE_IBL"] = true;
+    if (options?.lights)
+      parsedMaterial.defines["USE_LIGHTS"] = true;
+    if (material) {
+      parseMaterial(device, material, parsedMaterial);
+    }
+    return parsedMaterial;
+  }
+  function parseMaterial(device, material, parsedMaterial) {
+    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
+    if (material.pbrMetallicRoughness) {
+      parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
+    }
+    if (material.normalTexture) {
+      addTexture(device, material.normalTexture, "pbr_normalSampler", "HAS_NORMALMAP", parsedMaterial);
+      const { scale: scale12 = 1 } = material.normalTexture;
+      parsedMaterial.uniforms.normalScale = scale12;
+    }
+    if (material.occlusionTexture) {
+      addTexture(device, material.occlusionTexture, "pbr_occlusionSampler", "HAS_OCCLUSIONMAP", parsedMaterial);
+      const { strength = 1 } = material.occlusionTexture;
+      parsedMaterial.uniforms.occlusionStrength = strength;
+    }
+    if (material.emissiveTexture) {
+      addTexture(device, material.emissiveTexture, "pbr_emissiveSampler", "HAS_EMISSIVEMAP", parsedMaterial);
+      parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
+    }
+    switch (material.alphaMode || "MASK") {
+      case "MASK":
+        const { alphaCutoff = 0.5 } = material;
+        parsedMaterial.defines["ALPHA_CUTOFF"] = true;
+        parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
+        break;
+      case "BLEND":
+        import_core20.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
+        parsedMaterial.parameters.blend = true;
+        parsedMaterial.parameters.blendColorOperation = "add";
+        parsedMaterial.parameters.blendColorSrcFactor = "src-alpha";
+        parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
+        parsedMaterial.parameters.blendAlphaOperation = "add";
+        parsedMaterial.parameters.blendAlphaSrcFactor = "one";
+        parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
+        parsedMaterial.glParameters["blend"] = true;
+        parsedMaterial.glParameters["blendEquation"] = 32774;
+        parsedMaterial.glParameters["blendFunc"] = [
+          770,
+          771,
+          1,
+          771
+        ];
+        break;
+    }
+  }
+  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial) {
+    if (pbrMetallicRoughness.baseColorTexture) {
+      addTexture(device, pbrMetallicRoughness.baseColorTexture, "pbr_baseColorSampler", "HAS_BASECOLORMAP", parsedMaterial);
+    }
+    parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
+    if (pbrMetallicRoughness.metallicRoughnessTexture) {
+      addTexture(device, pbrMetallicRoughness.metallicRoughnessTexture, "pbr_metallicRoughnessSampler", "HAS_METALROUGHNESSMAP", parsedMaterial);
+    }
+    const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
+    parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
+  }
+  function addTexture(device, gltfTexture, uniformName, define2, parsedMaterial) {
+    const image = gltfTexture.texture.source.image;
+    const gltfSampler = {
+      wrapS: 10497,
+      // default REPEAT S (U) wrapping mode.
+      wrapT: 10497,
+      // default REPEAT T (V) wrapping mode.
+      minFilter: 9729,
+      // default LINEAR filtering
+      magFilter: 9729,
+      // default LINEAR filtering
+      ...gltfTexture?.texture?.sampler
+    };
+    const baseOptions = {
+      id: gltfTexture.uniformName || gltfTexture.id,
+      sampler: convertSampler(gltfSampler)
+    };
+    let texture;
+    if (image.compressed) {
+      texture = createCompressedTexture(device, image, baseOptions);
+    } else {
+      const { width, height } = device.getExternalImageSize(image);
+      texture = device.createTexture({
+        ...baseOptions,
+        width,
+        height,
+        data: image
+      });
+    }
+    parsedMaterial.bindings[uniformName] = texture;
+    if (define2)
+      parsedMaterial.defines[define2] = true;
+    parsedMaterial.generatedTextures.push(texture);
+  }
+  function createCompressedTextureFallback(device, baseOptions) {
+    return device.createTexture({
+      ...baseOptions,
+      format: "rgba8unorm",
+      width: 1,
+      height: 1,
+      mipLevels: 1
+    });
+  }
+  function resolveCompressedTextureFormat(level) {
+    return level.textureFormat;
+  }
+  function getMaxCompressedMipLevels(baseWidth, baseHeight, format) {
+    const { blockWidth = 1, blockHeight = 1 } = import_core20.textureFormatDecoder.getInfo(format);
+    let count = 1;
+    for (let i = 1; ; i++) {
+      const w2 = Math.max(1, baseWidth >> i);
+      const h = Math.max(1, baseHeight >> i);
+      if (w2 < blockWidth || h < blockHeight)
+        break;
+      count++;
+    }
+    return count;
+  }
+  function createCompressedTexture(device, image, baseOptions) {
+    let levels;
+    if (Array.isArray(image.data) && image.data[0]?.data) {
+      levels = image.data;
+    } else if ("mipmaps" in image && Array.isArray(image.mipmaps)) {
+      levels = image.mipmaps;
+    } else {
+      levels = [];
+    }
+    if (levels.length === 0 || !levels[0]?.data) {
+      import_core20.log.warn("createCompressedTexture: compressed image has no valid mip levels, creating fallback")();
+      return createCompressedTextureFallback(device, baseOptions);
+    }
+    const baseLevel = levels[0];
+    const baseWidth = baseLevel.width ?? image.width ?? 0;
+    const baseHeight = baseLevel.height ?? image.height ?? 0;
+    if (baseWidth <= 0 || baseHeight <= 0) {
+      import_core20.log.warn("createCompressedTexture: base level has invalid dimensions, creating fallback")();
+      return createCompressedTextureFallback(device, baseOptions);
+    }
+    const format = resolveCompressedTextureFormat(baseLevel);
+    if (!format) {
+      import_core20.log.warn("createCompressedTexture: compressed image has no textureFormat, creating fallback")();
+      return createCompressedTextureFallback(device, baseOptions);
+    }
+    const maxMipLevels = getMaxCompressedMipLevels(baseWidth, baseHeight, format);
+    const levelLimit = Math.min(levels.length, maxMipLevels);
+    let validLevelCount = 1;
+    for (let i = 1; i < levelLimit; i++) {
+      const level = levels[i];
+      if (!level.data || level.width <= 0 || level.height <= 0) {
+        import_core20.log.warn(`createCompressedTexture: mip level ${i} has invalid data/dimensions, truncating`)();
+        break;
+      }
+      const levelFormat = resolveCompressedTextureFormat(level);
+      if (levelFormat && levelFormat !== format) {
+        import_core20.log.warn(`createCompressedTexture: mip level ${i} format '${levelFormat}' differs from base '${format}', truncating`)();
+        break;
+      }
+      const expectedW = Math.max(1, baseWidth >> i);
+      const expectedH = Math.max(1, baseHeight >> i);
+      if (level.width !== expectedW || level.height !== expectedH) {
+        import_core20.log.warn(`createCompressedTexture: mip level ${i} dimensions ${level.width}x${level.height} don't match expected ${expectedW}x${expectedH}, truncating`)();
+        break;
+      }
+      validLevelCount++;
+    }
+    const texture = device.createTexture({
+      ...baseOptions,
+      format,
+      usage: import_core20.Texture.TEXTURE | import_core20.Texture.COPY_DST,
+      width: baseWidth,
+      height: baseHeight,
+      mipLevels: validLevelCount,
+      data: baseLevel.data
+    });
+    for (let i = 1; i < validLevelCount; i++) {
+      texture.writeData(levels[i].data, {
+        width: levels[i].width,
+        height: levels[i].height,
+        mipLevel: i
+      });
+    }
+    return texture;
+  }
+
+  // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting.js
+  var import_core21 = __toESM(require_core3(), 1);
+
+  // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting-glsl.js
+  var lightingUniformsGLSL = (
+    /* glsl */
+    `precision highp int;
+
+// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+struct AmbientLight {
+  vec3 color;
+};
+
+struct PointLight {
+  vec3 color;
+  vec3 position;
+  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
+};
+
+struct DirectionalLight {
+  vec3 color;
+  vec3 direction;
+};
+
 uniform lightingUniforms {
   int enabled;
   int lightType;
@@ -15732,6 +16413,16 @@ uniform lightingUniforms {
   vec3 lightPosition2;
   vec3 lightDirection2;
   vec3 lightAttenuation2;
+
+  vec3 lightColor3;
+  vec3 lightPosition3;
+  vec3 lightDirection3;
+  vec3 lightAttenuation3;
+
+  vec3 lightColor4;
+  vec3 lightPosition4;
+  vec3 lightDirection4;
+  vec3 lightAttenuation4;
 } lighting;
 
 PointLight lighting_getPointLight(int index) {
@@ -15741,8 +16432,12 @@ PointLight lighting_getPointLight(int index) {
     case 1:
       return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
     case 2:
-    default:  
       return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
+    case 3:
+      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);
+    case 4:
+    default:  
+      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);
   }
 }
 
@@ -15753,8 +16448,12 @@ DirectionalLight lighting_getDirectionalLight(int index) {
     case 1:
       return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
     case 2:
-    default:   
       return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
+    case 3:
+      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);
+    case 4:
+    default:   
+      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);
   }
 } 
 
@@ -15772,6 +16471,8 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
   var lightingUniformsWGSL = (
     /* wgsl */
     `// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+const MAX_LIGHTS: i32 = 5;
+
 struct AmbientLight {
   color: vec3<f32>,
 };
@@ -15789,32 +16490,80 @@ struct DirectionalLight {
 
 struct lightingUniforms {
   enabled: i32,
-  pointLightCount: i32,
+  lightType: i32,
+
   directionalLightCount: i32,
+  pointLightCount: i32,
 
   ambientColor: vec3<f32>,
 
-  // TODO - support multiple lights by uncommenting arrays below
-  lightType: i32,
-  lightColor: vec3<f32>,
-  lightDirection: vec3<f32>,
-  lightPosition: vec3<f32>,
-  lightAttenuation: vec3<f32>,
-
-  // AmbientLight ambientLight;
-  // PointLight pointLight[MAX_LIGHTS];
-  // DirectionalLight directionalLight[MAX_LIGHTS];
+  lightColor0: vec3<f32>,
+  lightPosition0: vec3<f32>,
+  lightDirection0: vec3<f32>,
+  lightAttenuation0: vec3<f32>,
+
+  lightColor1: vec3<f32>,
+  lightPosition1: vec3<f32>,
+  lightDirection1: vec3<f32>,
+  lightAttenuation1: vec3<f32>,
+
+  lightColor2: vec3<f32>,
+  lightPosition2: vec3<f32>,
+  lightDirection2: vec3<f32>,
+  lightAttenuation2: vec3<f32>,
+
+  lightColor3: vec3<f32>,
+  lightPosition3: vec3<f32>,
+  lightDirection3: vec3<f32>,
+  lightAttenuation3: vec3<f32>,
+
+  lightColor4: vec3<f32>,
+  lightPosition4: vec3<f32>,
+  lightDirection4: vec3<f32>,
+  lightAttenuation4: vec3<f32>,
 };
 
 // Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)
 @binding(1) @group(0) var<uniform> lighting : lightingUniforms;
 
 fn lighting_getPointLight(index: i32) -> PointLight {
-  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
+  switch (index) {
+    case 0: {
+      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);
+    }
+    case 1: {
+      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
+    }
+    case 2: {
+      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
+    }
+    case 3: {
+      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);
+    }
+    case 4, default: {
+      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);
+    }
+  }
 }
 
 fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
-  return DirectionalLight(lighting.lightColor, lighting.lightDirection);
+  switch (index) {
+    case 0: {
+      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);
+    }
+    case 1: {
+      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
+    }
+    case 2: {
+      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
+    }
+    case 3: {
+      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);
+    }
+    case 4, default: {
+      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);
+    }
+  }
 } 
 
 fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
@@ -15859,7 +16608,15 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
       lightColor2: "vec3<f32>",
       lightPosition2: "vec3<f32>",
       lightDirection2: "vec3<f32>",
-      lightAttenuation2: "vec3<f32>"
+      lightAttenuation2: "vec3<f32>",
+      lightColor3: "vec3<f32>",
+      lightPosition3: "vec3<f32>",
+      lightDirection3: "vec3<f32>",
+      lightAttenuation3: "vec3<f32>",
+      lightColor4: "vec3<f32>",
+      lightPosition4: "vec3<f32>",
+      lightDirection4: "vec3<f32>",
+      lightAttenuation4: "vec3<f32>"
     },
     defaultUniforms: {
       enabled: 1,
@@ -15879,7 +16636,15 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
       lightColor2: [1, 1, 1],
       lightPosition2: [1, 1, 2],
       lightDirection2: [1, 1, 1],
-      lightAttenuation2: [1, 0, 0]
+      lightAttenuation2: [1, 0, 0],
+      lightColor3: [1, 1, 1],
+      lightPosition3: [1, 1, 2],
+      lightDirection3: [1, 1, 1],
+      lightAttenuation3: [1, 0, 0],
+      lightColor4: [1, 1, 1],
+      lightPosition4: [1, 1, 2],
+      lightDirection4: [1, 1, 1],
+      lightAttenuation4: [1, 0, 0]
     },
     source: lightingUniformsWGSL,
     vs: lightingUniformsGLSL,
@@ -15913,26 +16678,36 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
     const lightSourceUniforms = {};
     lightSourceUniforms.ambientColor = convertColor(ambientLight);
     let currentLight = 0;
+    let pointLightCount = 0;
+    let directionalLightCount = 0;
     for (const pointLight of pointLights) {
+      if (currentLight >= MAX_LIGHTS) {
+        break;
+      }
       lightSourceUniforms.lightType = LIGHT_TYPE.POINT;
       const i = currentLight;
       lightSourceUniforms[`lightColor${i}`] = convertColor(pointLight);
       lightSourceUniforms[`lightPosition${i}`] = pointLight.position;
       lightSourceUniforms[`lightAttenuation${i}`] = pointLight.attenuation || [1, 0, 0];
       currentLight++;
+      pointLightCount++;
     }
     for (const directionalLight of directionalLights) {
+      if (currentLight >= MAX_LIGHTS) {
+        break;
+      }
       lightSourceUniforms.lightType = LIGHT_TYPE.DIRECTIONAL;
       const i = currentLight;
       lightSourceUniforms[`lightColor${i}`] = convertColor(directionalLight);
       lightSourceUniforms[`lightDirection${i}`] = directionalLight.direction;
       currentLight++;
+      directionalLightCount++;
     }
-    if (currentLight > MAX_LIGHTS) {
-      import_core21.log.warn("MAX_LIGHTS exceeded")();
+    if (pointLights.length + directionalLights.length > MAX_LIGHTS) {
+      import_core21.log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
     }
-    lightSourceUniforms.directionalLightCount = directionalLights.length;
-    lightSourceUniforms.pointLightCount = pointLights.length;
+    lightSourceUniforms.directionalLightCount = directionalLightCount;
+    lightSourceUniforms.pointLightCount = pointLightCount;
     return lightSourceUniforms;
   }
   function extractLightTypes(lights) {
@@ -16465,51 +17240,55 @@ vec4 pbr_filterColor(vec4 colorUnused)
     `struct PBRFragmentInputs {
   pbr_vPosition: vec3f,
   pbr_vUV: vec2f,
-  pbr_vTBN: mat3f,
+  pbr_vTBN: mat3x3f,
   pbr_vNormal: vec3f
 };
 
-var fragmentInputs: PBRFragmentInputs;
+var<private> fragmentInputs: PBRFragmentInputs;
 
 fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f, uv: vec2f)
 {
   var pos: vec4f = pbrProjection.modelMatrix * position;
-  fragmentInputs.pbr_vPosition = vec3(pos.xyz) / pos.w;
+  fragmentInputs.pbr_vPosition = pos.xyz / pos.w;
+  fragmentInputs.pbr_vNormal = vec3f(0.0, 0.0, 1.0);
+  fragmentInputs.pbr_vTBN = mat3x3f(
+    vec3f(1.0, 0.0, 0.0),
+    vec3f(0.0, 1.0, 0.0),
+    vec3f(0.0, 0.0, 1.0)
+  );
+  fragmentInputs.pbr_vUV = vec2f(0.0, 0.0);
 
 #ifdef HAS_NORMALS
+  let normalW: vec3f = normalize((pbrProjection.normalMatrix * vec4f(normal.xyz, 0.0)).xyz);
+  fragmentInputs.pbr_vNormal = normalW;
 #ifdef HAS_TANGENTS
-  let normalW: vec3f = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
-  let tangentW: vec3f = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
+  let tangentW: vec3f = normalize((pbrProjection.modelMatrix * vec4f(tangent.xyz, 0.0)).xyz);
   let bitangentW: vec3f = cross(normalW, tangentW) * tangent.w;
-  fragmentInputs.pbr_vTBN = mat3(tangentW, bitangentW, normalW);
-#else // HAS_TANGENTS != 1
-  fragmentInputs.pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
+  fragmentInputs.pbr_vTBN = mat3x3f(tangentW, bitangentW, normalW);
 #endif
 #endif
 
 #ifdef HAS_UV
   fragmentInputs.pbr_vUV = uv;
-#else
-  fragmentInputs.pbr_vUV = vec2(0.,0.);
 #endif
 }
 
 struct pbrMaterialUniforms {
   // Material is unlit
-  unlit: uint32,
+  unlit: u32,
 
   // Base color map
-  baseColorMapEnabled: uint32,
+  baseColorMapEnabled: u32,
   baseColorFactor: vec4f,
 
-  normalMapEnabled : uint32,
+  normalMapEnabled : u32,
   normalScale: f32,  // #ifdef HAS_NORMALMAP
 
-  emissiveMapEnabled: uint32,
+  emissiveMapEnabled: u32,
   emissiveFactor: vec3f, // #ifdef HAS_EMISSIVEMAP
 
   metallicRoughnessValues: vec2f,
-  metallicRoughnessMapEnabled: uint32,
+  metallicRoughnessMapEnabled: u32,
 
   occlusionMapEnabled: i32,
   occlusionStrength: f32, // #ifdef HAS_OCCLUSIONMAP
@@ -16524,7 +17303,7 @@ struct pbrMaterialUniforms {
   // debugging flags used for shader output of intermediate PBR variables
   // #ifdef PBR_DEBUG
   scaleDiffBaseMR: vec4f,
-  scaleFGDSpec: vec4f
+  scaleFGDSpec: vec4f,
   // #endif
 }
 
@@ -16532,24 +17311,32 @@ struct pbrMaterialUniforms {
 
 // Samplers
 #ifdef HAS_BASECOLORMAP
-uniform sampler2D pbr_baseColorSampler;
+@binding(3) @group(0) var pbr_baseColorSampler: texture_2d<f32>;
+@binding(4) @group(0) var pbr_baseColorSamplerSampler: sampler;
 #endif
 #ifdef HAS_NORMALMAP
-uniform sampler2D pbr_normalSampler;
+@binding(5) @group(0) var pbr_normalSampler: texture_2d<f32>;
+@binding(6) @group(0) var pbr_normalSamplerSampler: sampler;
 #endif
 #ifdef HAS_EMISSIVEMAP
-uniform sampler2D pbr_emissiveSampler;
+@binding(7) @group(0) var pbr_emissiveSampler: texture_2d<f32>;
+@binding(8) @group(0) var pbr_emissiveSamplerSampler: sampler;
 #endif
 #ifdef HAS_METALROUGHNESSMAP
-uniform sampler2D pbr_metallicRoughnessSampler;
+@binding(9) @group(0) var pbr_metallicRoughnessSampler: texture_2d<f32>;
+@binding(10) @group(0) var pbr_metallicRoughnessSamplerSampler: sampler;
 #endif
 #ifdef HAS_OCCLUSIONMAP
-uniform sampler2D pbr_occlusionSampler;
+@binding(11) @group(0) var pbr_occlusionSampler: texture_2d<f32>;
+@binding(12) @group(0) var pbr_occlusionSamplerSampler: sampler;
 #endif
 #ifdef USE_IBL
-uniform samplerCube pbr_diffuseEnvSampler;
-uniform samplerCube pbr_specularEnvSampler;
-uniform sampler2D pbr_brdfLUT;
+@binding(13) @group(0) var pbr_diffuseEnvSampler: texture_cube<f32>;
+@binding(14) @group(0) var pbr_diffuseEnvSamplerSampler: sampler;
+@binding(15) @group(0) var pbr_specularEnvSampler: texture_cube<f32>;
+@binding(16) @group(0) var pbr_specularEnvSamplerSampler: sampler;
+@binding(17) @group(0) var pbr_BrdfLUT: texture_2d<f32>;
+@binding(18) @group(0) var pbr_BrdfLUTSampler: sampler;
 #endif
 
 // Encapsulate the various inputs used by the various functions in the shading equation
@@ -16577,17 +17364,19 @@ const c_MinRoughness = 0.04;
 
 fn SRGBtoLINEAR(srgbIn: vec4f ) -> vec4f
 {
+  var linOut: vec3f = srgbIn.xyz;
 #ifdef MANUAL_SRGB
+  let bLess: vec3f = step(vec3f(0.04045), srgbIn.xyz);
+  linOut = mix(
+    srgbIn.xyz / vec3f(12.92),
+    pow((srgbIn.xyz + vec3f(0.055)) / vec3f(1.055), vec3f(2.4)),
+    bLess
+  );
 #ifdef SRGB_FAST_APPROXIMATION
-  var linOut: vec3f = pow(srgbIn.xyz,vec3(2.2));
-#else // SRGB_FAST_APPROXIMATION
-  var bLess: vec3f = step(vec3(0.04045),srgbIn.xyz);
-  var linOut: vec3f = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
-#endif //SRGB_FAST_APPROXIMATION
-  return vec4f(linOut,srgbIn.w);;
-#else //MANUAL_SRGB
-  return srgbIn;
-#endif //MANUAL_SRGB
+  linOut = pow(srgbIn.xyz, vec3f(2.2));
+#endif
+#endif
+  return vec4f(linOut, srgbIn.w);
 }
 
 // Find the normal for this fragment, pulling either from a predefined normal map
@@ -16595,32 +17384,28 @@ fn SRGBtoLINEAR(srgbIn: vec4f ) -> vec4f
 fn getNormal() -> vec3f
 {
   // Retrieve the tangent space matrix
-#ifndef HAS_TANGENTS
-  var pos_dx: vec3f = dFdx(fragmentInputs.pbr_vPosition);
-  var pos_dy: vec3f = dFdy(fragmentInputs.pbr_vPosition);
-  var tex_dx: vec3f = dFdx(vec3(fragmentInputs.pbr_vUV, 0.0));
-  var tex_dy: vec3f = dFdy(vec3(fragmentInputs.pbr_vUV, 0.0));
-  var t: vec3f = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
+  let pos_dx: vec3f = dpdx(fragmentInputs.pbr_vPosition);
+  let pos_dy: vec3f = dpdy(fragmentInputs.pbr_vPosition);
+  let tex_dx: vec3f = dpdx(vec3f(fragmentInputs.pbr_vUV, 0.0));
+  let tex_dy: vec3f = dpdy(vec3f(fragmentInputs.pbr_vUV, 0.0));
+  var t: vec3f = (tex_dy.y * pos_dx - tex_dx.y * pos_dy) / (tex_dx.x * tex_dy.y - tex_dy.x * tex_dx.y);
 
-#ifdef HAS_NORMALS
-  var ng: vec3f = normalize(fragmentInputs.pbr_vNormal);
-#else
   var ng: vec3f = cross(pos_dx, pos_dy);
+#ifdef HAS_NORMALS
+  ng = normalize(fragmentInputs.pbr_vNormal);
 #endif
-
   t = normalize(t - ng * dot(ng, t));
   var b: vec3f = normalize(cross(ng, t));
-  var tbn: mat3f = mat3f(t, b, ng);
-#else // HAS_TANGENTS
-  var tbn: mat3f = fragmentInputs.pbr_vTBN;
+  var tbn: mat3x3f = mat3x3f(t, b, ng);
+#ifdef HAS_TANGENTS
+  tbn = fragmentInputs.pbr_vTBN;
 #endif
 
-#ifdef HAS_NORMALMAP
-  vec3 n = texture(pbr_normalSampler, fragmentInputs.pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
-#else
   // The tbn matrix is linearly interpolated, so we need to re-normalize
-  vec3 n = normalize(tbn[2].xyz);
+  var n: vec3f = normalize(tbn[2].xyz);
+#ifdef HAS_NORMALMAP
+  n = textureSample(pbr_normalSampler, pbr_normalSamplerSampler, fragmentInputs.pbr_vUV).rgb;
+  n = normalize(tbn * ((2.0 * n - 1.0) * vec3f(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
 #endif
 
   return n;
@@ -16630,27 +17415,37 @@ fn getNormal() -> vec3f
 // Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
 // See our README.md on Environment Maps [3] for additional discussion.
 #ifdef USE_IBL
-fn getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection) -> vec3f
+fn getIBLContribution(pbrInfo: PBRInfo, n: vec3f, reflection: vec3f) -> vec3f
 {
-  float mipCount = 9.0; // resolution of 512x512
-  float lod = (pbrInfo.perceptualRoughness * mipCount);
+  let mipCount: f32 = 9.0; // resolution of 512x512
+  let lod: f32 = pbrInfo.perceptualRoughness * mipCount;
   // retrieve a scale and bias to F0. See [1], Figure 3
-  vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
-    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
-  vec3 diffuseLight = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, n)).rgb;
-
+  let brdf = SRGBtoLINEAR(
+    textureSample(
+      pbr_BrdfLUT,
+      pbr_BrdfLUTSampler,
+      vec2f(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness)
+    )
+  ).rgb;
+  let diffuseLight =
+    SRGBtoLINEAR(textureSample(pbr_diffuseEnvSampler, pbr_diffuseEnvSamplerSampler, n)).rgb;
+  let specularLightDefault =
+    SRGBtoLINEAR(textureSample(pbr_specularEnvSampler, pbr_specularEnvSamplerSampler, reflection)).rgb;
+  var specularLight = specularLightDefault;
 #ifdef USE_TEX_LOD
-  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
-#else
-  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
+  specularLight = SRGBtoLINEAR(
+    textureSampleLevel(
+      pbr_specularEnvSampler,
+      pbr_specularEnvSamplerSampler,
+      reflection,
+      lod
+    )
+  ).rgb;
 #endif
 
-  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
-  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
-
-  // For presentation, this allows us to disable IBL terms
-  diffuse *= pbrMaterial.scaleIBLAmbient.x;
-  specular *= pbrMaterial.scaleIBLAmbient.y;
+  let diffuse = diffuseLight * pbrInfo.diffuseColor * pbrMaterial.scaleIBLAmbient.x;
+  let specular =
+    specularLight * (pbrInfo.specularColor * brdf.x + brdf.y) * pbrMaterial.scaleIBLAmbient.y;
 
   return diffuse + specular;
 }
@@ -16694,7 +17489,7 @@ fn geometricOcclusion(pbrInfo: PBRInfo) -> f32 {
 fn microfacetDistribution(pbrInfo: PBRInfo) -> f32 {
   let roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
   let f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
-  return roughnessSq / (PI * f * f);
+  return roughnessSq / (M_PI * f * f);
 }
 
 fn PBRInfo_setAmbientLight(pbrInfo: ptr<function, PBRInfo>) {
@@ -16736,11 +17531,11 @@ fn calculateFinalColor(pbrInfo: PBRInfo, lightColor: vec3<f32>) -> vec3<f32> {
 
 fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   // The albedo may be defined from a base texture or a flat color
-  var baseColor: vec4<f32>;
+  var baseColor: vec4<f32> = pbrMaterial.baseColorFactor;
   #ifdef HAS_BASECOLORMAP
-  baseColor = SRGBtoLINEAR(textureSample(pbr_baseColorSampler, pbr_baseColorSampler, fragmentInputs.pbr_vUV)) * pbrMaterial.baseColorFactor;
-  #else
-  baseColor = pbrMaterial.baseColorFactor;
+  baseColor = SRGBtoLINEAR(
+    textureSample(pbr_baseColorSampler, pbr_baseColorSamplerSampler, fragmentInputs.pbr_vUV)
+  ) * pbrMaterial.baseColorFactor;
   #endif
 
   #ifdef ALPHA_CUTOFF
@@ -16751,7 +17546,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
 
   var color = vec3<f32>(0.0, 0.0, 0.0);
 
-  if (pbrMaterial.unlit) {
+  if (pbrMaterial.unlit != 0u) {
     color = baseColor.rgb;
   } else {
     // Metallic and Roughness material properties are packed together
@@ -16762,7 +17557,11 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     #ifdef HAS_METALROUGHNESSMAP
     // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
     // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
-    let mrSample = textureSample(pbr_metallicRoughnessSampler, pbr_metallicRoughnessSampler, fragmentInputs.pbr_vUV);
+    let mrSample = textureSample(
+      pbr_metallicRoughnessSampler,
+      pbr_metallicRoughnessSamplerSampler,
+      fragmentInputs.pbr_vUV
+    );
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
     #endif
@@ -16839,22 +17638,25 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
 
     // Calculate lighting contribution from image based lighting source (IBL)
     #ifdef USE_IBL
-    if (pbrMaterial.IBLenabled) {
+    if (pbrMaterial.IBLenabled != 0) {
       color += getIBLContribution(pbrInfo, n, reflection);
     }
     #endif
 
     // Apply optional PBR terms for additional (optional) shading
     #ifdef HAS_OCCLUSIONMAP
-    if (pbrMaterial.occlusionMapEnabled) {
-      let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSampler, fragmentInputs.pbr_vUV).r;
+    if (pbrMaterial.occlusionMapEnabled != 0) {
+      let ao =
+        textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, fragmentInputs.pbr_vUV).r;
       color = mix(color, color * ao, pbrMaterial.occlusionStrength);
     }
     #endif
 
     #ifdef HAS_EMISSIVEMAP
-    if (pbrMaterial.emissiveMapEnabled) {
-      let emissive = SRGBtoLINEAR(textureSample(pbr_emissiveSampler, pbr_emissiveSampler, fragmentInputs.pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
+    if (pbrMaterial.emissiveMapEnabled != 0u) {
+      let emissive = SRGBtoLINEAR(
+        textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, fragmentInputs.pbr_vUV)
+      ).rgb * pbrMaterial.emissiveFactor;
       color += emissive;
     }
     #endif
@@ -16890,10 +17692,23 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   mat4 normalMatrix;
   vec3 camera;
 } pbrProjection;
+`
+  );
+  var wgslUniformBlock = (
+    /* wgsl */
+    `struct pbrProjectionUniforms {
+  modelViewProjectionMatrix: mat4x4<f32>,
+  modelMatrix: mat4x4<f32>,
+  normalMatrix: mat4x4<f32>,
+  camera: vec3<f32>
+};
+
+@binding(0) @group(0) var<uniform> pbrProjection: pbrProjectionUniforms;
 `
   );
   var pbrProjection = {
     name: "pbrProjection",
+    source: wgslUniformBlock,
     vs: uniformBlock2,
     fs: uniformBlock2,
     // TODO why is this needed?
@@ -16902,7 +17717,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       modelViewProjectionMatrix: "mat4x4<f32>",
       modelMatrix: "mat4x4<f32>",
       normalMatrix: "mat4x4<f32>",
-      camera: "vec3<i32>"
+      camera: "vec3<f32>"
     }
   };
 
@@ -17608,227 +18423,34 @@ void main(void) {
       scratchPosition2.from(cartesian);
       const positionX = scratchPosition2.x;
       const positionY = scratchPosition2.y;
-      const positionZ = scratchPosition2.z;
-      const oneOverRadiiSquared = this.oneOverRadiiSquared;
-      const beta = 1 / Math.sqrt(positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z);
-      return scratchPosition2.multiplyScalar(beta).to(result);
-    }
-    /** Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
-     * its components by the result of `Ellipsoid#oneOverRadii` */
-    transformPositionToScaledSpace(position, result = [0, 0, 0]) {
-      return scratchPosition2.from(position).scale(this.oneOverRadii).to(result);
-    }
-    /** Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
-     * its components by the result of `Ellipsoid#radii`. */
-    transformPositionFromScaledSpace(position, result = [0, 0, 0]) {
-      return scratchPosition2.from(position).scale(this.radii).to(result);
-    }
-    /** Computes a point which is the intersection of the surface normal with the z-axis. */
-    getSurfaceNormalIntersectionWithZAxis(position, buffer = 0, result = [0, 0, 0]) {
-      assert2(equals7(this.radii.x, this.radii.y, math_utils_exports.EPSILON15));
-      assert2(this.radii.z > 0);
-      scratchPosition2.from(position);
-      const z = scratchPosition2.z * (1 - this.squaredXOverSquaredZ);
-      if (Math.abs(z) >= this.radii.z - buffer) {
-        return void 0;
-      }
-      return scratchPosition2.set(0, 0, z).to(result);
-    }
-  };
-  Ellipsoid.WGS84 = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
-
-  // ../../node_modules/@loaders.gl/tiles/node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
-  function getHiResTimestamp3() {
-    let timestamp;
-    if (typeof window !== "undefined" && window.performance) {
-      timestamp = window.performance.now();
-    } else if (typeof process !== "undefined" && process.hrtime) {
-      const timeParts = process.hrtime();
-      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
-    } else {
-      timestamp = Date.now();
-    }
-    return timestamp;
-  }
-
-  // ../../node_modules/@loaders.gl/tiles/node_modules/@probe.gl/stats/dist/lib/stat.js
-  var Stat2 = class {
-    constructor(name12, type) {
-      this.sampleSize = 1;
-      this.time = 0;
-      this.count = 0;
-      this.samples = 0;
-      this.lastTiming = 0;
-      this.lastSampleTime = 0;
-      this.lastSampleCount = 0;
-      this._count = 0;
-      this._time = 0;
-      this._samples = 0;
-      this._startTime = 0;
-      this._timerPending = false;
-      this.name = name12;
-      this.type = type;
-      this.reset();
-    }
-    reset() {
-      this.time = 0;
-      this.count = 0;
-      this.samples = 0;
-      this.lastTiming = 0;
-      this.lastSampleTime = 0;
-      this.lastSampleCount = 0;
-      this._count = 0;
-      this._time = 0;
-      this._samples = 0;
-      this._startTime = 0;
-      this._timerPending = false;
-      return this;
-    }
-    setSampleSize(samples) {
-      this.sampleSize = samples;
-      return this;
-    }
-    /** Call to increment count (+1) */
-    incrementCount() {
-      this.addCount(1);
-      return this;
-    }
-    /** Call to decrement count (-1) */
-    decrementCount() {
-      this.subtractCount(1);
-      return this;
-    }
-    /** Increase count */
-    addCount(value) {
-      this._count += value;
-      this._samples++;
-      this._checkSampling();
-      return this;
-    }
-    /** Decrease count */
-    subtractCount(value) {
-      this._count -= value;
-      this._samples++;
-      this._checkSampling();
-      return this;
-    }
-    /** Add an arbitrary timing and bump the count */
-    addTime(time) {
-      this._time += time;
-      this.lastTiming = time;
-      this._samples++;
-      this._checkSampling();
-      return this;
-    }
-    /** Start a timer */
-    timeStart() {
-      this._startTime = getHiResTimestamp3();
-      this._timerPending = true;
-      return this;
-    }
-    /** End a timer. Adds to time and bumps the timing count. */
-    timeEnd() {
-      if (!this._timerPending) {
-        return this;
-      }
-      this.addTime(getHiResTimestamp3() - this._startTime);
-      this._timerPending = false;
-      this._checkSampling();
-      return this;
-    }
-    getSampleAverageCount() {
-      return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
-    }
-    /** Calculate average time / count for the previous window */
-    getSampleAverageTime() {
-      return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
-    }
-    /** Calculate counts per second for the previous window */
-    getSampleHz() {
-      return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
-    }
-    getAverageCount() {
-      return this.samples > 0 ? this.count / this.samples : 0;
-    }
-    /** Calculate average time / count */
-    getAverageTime() {
-      return this.samples > 0 ? this.time / this.samples : 0;
-    }
-    /** Calculate counts per second */
-    getHz() {
-      return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
-    }
-    _checkSampling() {
-      if (this._samples === this.sampleSize) {
-        this.lastSampleTime = this._time;
-        this.lastSampleCount = this._count;
-        this.count += this._count;
-        this.time += this._time;
-        this.samples += this._samples;
-        this._time = 0;
-        this._count = 0;
-        this._samples = 0;
-      }
-    }
-  };
-
-  // ../../node_modules/@loaders.gl/tiles/node_modules/@probe.gl/stats/dist/lib/stats.js
-  var Stats2 = class {
-    constructor(options) {
-      this.stats = {};
-      this.id = options.id;
-      this.stats = {};
-      this._initializeStats(options.stats);
-      Object.seal(this);
-    }
-    /** Acquire a stat. Create if it doesn't exist. */
-    get(name12, type = "count") {
-      return this._getOrCreate({ name: name12, type });
-    }
-    get size() {
-      return Object.keys(this.stats).length;
-    }
-    /** Reset all stats */
-    reset() {
-      for (const stat of Object.values(this.stats)) {
-        stat.reset();
-      }
-      return this;
-    }
-    forEach(fn) {
-      for (const stat of Object.values(this.stats)) {
-        fn(stat);
-      }
+      const positionZ = scratchPosition2.z;
+      const oneOverRadiiSquared = this.oneOverRadiiSquared;
+      const beta = 1 / Math.sqrt(positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z);
+      return scratchPosition2.multiplyScalar(beta).to(result);
     }
-    getTable() {
-      const table = {};
-      this.forEach((stat) => {
-        table[stat.name] = {
-          time: stat.time || 0,
-          count: stat.count || 0,
-          average: stat.getAverageTime() || 0,
-          hz: stat.getHz() || 0
-        };
-      });
-      return table;
+    /** Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
+     * its components by the result of `Ellipsoid#oneOverRadii` */
+    transformPositionToScaledSpace(position, result = [0, 0, 0]) {
+      return scratchPosition2.from(position).scale(this.oneOverRadii).to(result);
     }
-    _initializeStats(stats = []) {
-      stats.forEach((stat) => this._getOrCreate(stat));
+    /** Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
+     * its components by the result of `Ellipsoid#radii`. */
+    transformPositionFromScaledSpace(position, result = [0, 0, 0]) {
+      return scratchPosition2.from(position).scale(this.radii).to(result);
     }
-    _getOrCreate(stat) {
-      const { name: name12, type } = stat;
-      let result = this.stats[name12];
-      if (!result) {
-        if (stat instanceof Stat2) {
-          result = stat;
-        } else {
-          result = new Stat2(name12, type);
-        }
-        this.stats[name12] = result;
+    /** Computes a point which is the intersection of the surface normal with the z-axis. */
+    getSurfaceNormalIntersectionWithZAxis(position, buffer = 0, result = [0, 0, 0]) {
+      assert2(equals7(this.radii.x, this.radii.y, math_utils_exports.EPSILON15));
+      assert2(this.radii.z > 0);
+      scratchPosition2.from(position);
+      const z = scratchPosition2.z * (1 - this.squaredXOverSquaredZ);
+      if (Math.abs(z) >= this.radii.z - buffer) {
+        return void 0;
       }
-      return result;
+      return scratchPosition2.set(0, 0, z).to(result);
     }
   };
+  Ellipsoid.WGS84 = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
 
   // ../../node_modules/@loaders.gl/tiles/dist/utils/doubly-linked-list-node.js
   var DoublyLinkedListNode = class {
@@ -19774,7 +20396,7 @@ void main(void) {
       this.memoryAdjustedScreenSpaceError = this.options.maximumScreenSpaceError;
       this._cacheBytes = this.options.maximumMemoryUsage * 1024 * 1024;
       this._cacheOverflowBytes = this.options.memoryCacheOverflow * 1024 * 1024;
-      this.stats = new Stats2({ id: this.url });
+      this.stats = new Stats({ id: this.url });
       this._initializeStats();
       this.tilesetInitializationPromise = this._initializeTileSet(tileset);
     }
@@ -20334,7 +20956,7 @@ void main(void) {
   };
 
   // ../../node_modules/@loaders.gl/3d-tiles/dist/lib/utils/version.js
-  var VERSION8 = true ? "4.4.0-alpha.16" : "latest";
+  var VERSION9 = true ? "4.4.0-alpha.18" : "latest";
 
   // ../../node_modules/@loaders.gl/3d-tiles/dist/lib/constants.js
   var TILE3D_TYPE = {
@@ -20453,7 +21075,7 @@ void main(void) {
   }
 
   // ../../node_modules/@loaders.gl/draco/dist/lib/utils/version.js
-  var VERSION9 = true ? "4.4.0-alpha.16" : "latest";
+  var VERSION10 = true ? "4.4.0-alpha.18" : "latest";
 
   // ../../node_modules/@loaders.gl/schema-utils/dist/lib/schema/data-type.js
   function getDataTypeFromTypedArray(array) {
@@ -21024,7 +21646,7 @@ void main(void) {
     id: "draco",
     module: "draco",
     // shapes: ['mesh'],
-    version: VERSION9,
+    version: VERSION10,
     worker: true,
     extensions: ["drc"],
     mimeTypes: ["application/octet-stream"],
@@ -21034,7 +21656,6 @@ void main(void) {
       draco: {
         decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
         // 'js' for IE11
-        libraryPath: "libs/",
         extraAttributes: {},
         attributeNameEntry: void 0
       }
@@ -21045,7 +21666,7 @@ void main(void) {
     parse
   };
   async function parse(arrayBuffer, options) {
-    const { draco } = await loadDracoDecoderModule(options?.core, options?.draco?.decoderType || "wasm");
+    const { draco } = await loadDracoDecoderModule(extractLoadLibraryOptions(options), options?.draco?.decoderType || "wasm");
     const dracoParser = new DracoParser(draco);
     try {
       return dracoParser.parseSync(arrayBuffer, options?.draco);
@@ -23651,690 +24272,246 @@ void main(void) {
     for (const value of array) {
       numberArray.push(Number(value));
     }
-    const Construct = COMPONENT_TYPE_TO_ARRAY_CONSTRUCTOR[componentType];
-    if (!Construct) {
-      throw new Error("Illegal component type");
-    }
-    return new Construct(numberArray);
-  }
-  function createPropertyDataString(strings) {
-    const utf8Encode = new TextEncoder();
-    const arr = [];
-    let len5 = 0;
-    for (const str7 of strings) {
-      const uint8Array = utf8Encode.encode(str7);
-      len5 += uint8Array.length;
-      arr.push(uint8Array);
-    }
-    const strArray = new Uint8Array(len5);
-    const strOffsets = [];
-    let offset = 0;
-    for (const str7 of arr) {
-      strArray.set(str7, offset);
-      strOffsets.push(offset);
-      offset += str7.length;
-    }
-    strOffsets.push(offset);
-    const stringOffsetsTypedArray = new Uint32Array(strOffsets);
-    return { stringData: strArray, stringOffsets: stringOffsetsTypedArray };
-  }
-  function createBufferView(typedArray, scenegraph) {
-    scenegraph.gltf.buffers.push({
-      arrayBuffer: ensureArrayBuffer(typedArray.buffer),
-      byteOffset: typedArray.byteOffset,
-      byteLength: typedArray.byteLength
-    });
-    return scenegraph.addBufferView(typedArray);
-  }
-
-  // ../../node_modules/@loaders.gl/gltf/dist/lib/extensions/deprecated/EXT_feature_metadata.js
-  var EXT_feature_metadata_exports = {};
-  __export(EXT_feature_metadata_exports, {
-    decode: () => decode3,
-    name: () => name3
-  });
-  var EXT_FEATURE_METADATA_NAME = "EXT_feature_metadata";
-  var name3 = EXT_FEATURE_METADATA_NAME;
-  async function decode3(gltfData, options) {
-    const scenegraph = new GLTFScenegraph(gltfData);
-    decodeExtFeatureMetadata(scenegraph, options);
-  }
-  function decodeExtFeatureMetadata(scenegraph, options) {
-    if (!options.gltf?.loadBuffers) {
-      return;
-    }
-    const extension = scenegraph.getExtension(EXT_FEATURE_METADATA_NAME);
-    if (!extension) {
-      return;
-    }
-    if (options.gltf?.loadImages) {
-      decodePropertyTextures2(scenegraph, extension);
-    }
-    decodePropertyTables2(scenegraph, extension);
-  }
-  function decodePropertyTextures2(scenegraph, extension) {
-    const schema = extension.schema;
-    if (!schema) {
-      return;
-    }
-    const schemaClasses = schema.classes;
-    const { featureTextures } = extension;
-    if (schemaClasses && featureTextures) {
-      for (const schemaName in schemaClasses) {
-        const schemaClass = schemaClasses[schemaName];
-        const featureTexture = findFeatureTextureByClass(featureTextures, schemaName);
-        if (featureTexture) {
-          handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass);
-        }
-      }
-    }
-  }
-  function decodePropertyTables2(scenegraph, extension) {
-    const schema = extension.schema;
-    if (!schema) {
-      return;
-    }
-    const schemaClasses = schema.classes;
-    const propertyTables = extension.featureTables;
-    if (schemaClasses && propertyTables) {
-      for (const schemaName in schemaClasses) {
-        const propertyTable = findPropertyTableByClass2(propertyTables, schemaName);
-        if (propertyTable) {
-          processPropertyTable2(scenegraph, schema, propertyTable);
-        }
-      }
-    }
-  }
-  function findPropertyTableByClass2(propertyTables, schemaClassName) {
-    for (const propertyTableName in propertyTables) {
-      const propertyTable = propertyTables[propertyTableName];
-      if (propertyTable.class === schemaClassName) {
-        return propertyTable;
-      }
-    }
-    return null;
-  }
-  function findFeatureTextureByClass(featureTextures, schemaClassName) {
-    for (const featureTexturesName in featureTextures) {
-      const featureTable = featureTextures[featureTexturesName];
-      if (featureTable.class === schemaClassName) {
-        return featureTable;
-      }
-    }
-    return null;
-  }
-  function processPropertyTable2(scenegraph, schema, propertyTable) {
-    if (!propertyTable.class) {
-      return;
-    }
-    const schemaClass = schema.classes?.[propertyTable.class];
-    if (!schemaClass) {
-      throw new Error(`Incorrect data in the EXT_structural_metadata extension: no schema class with name ${propertyTable.class}`);
-    }
-    const numberOfElements = propertyTable.count;
-    for (const propertyName in schemaClass.properties) {
-      const classProperty = schemaClass.properties[propertyName];
-      const propertyTableProperty = propertyTable.properties?.[propertyName];
-      if (propertyTableProperty) {
-        const data = getPropertyDataFromBinarySource2(scenegraph, schema, classProperty, numberOfElements, propertyTableProperty);
-        propertyTableProperty.data = data;
-      }
-    }
-  }
-  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 getPropertyDataFromBinarySource2(scenegraph, schema, classProperty, numberOfFeatures, featureTableProperty) {
-    let data = [];
-    const bufferView = featureTableProperty.bufferView;
-    const dataArray = scenegraph.getTypedArrayForBufferView(bufferView);
-    const arrayOffsets = getArrayOffsetsForProperty2(scenegraph, classProperty, featureTableProperty, numberOfFeatures);
-    const stringOffsets = getStringOffsetsForProperty2(scenegraph, classProperty, featureTableProperty, numberOfFeatures);
-    if (classProperty.type === "STRING" || classProperty.componentType === "STRING") {
-      data = getPropertyDataString(numberOfFeatures, dataArray, arrayOffsets, stringOffsets);
-    } else if (isNumericProperty(classProperty)) {
-      data = getPropertyDataNumeric2(classProperty, numberOfFeatures, dataArray, arrayOffsets);
-    }
-    return data;
-  }
-  function getArrayOffsetsForProperty2(scenegraph, classProperty, propertyTableProperty, numberOfElements) {
-    if (classProperty.type === "ARRAY" && // `componentCount` is a number of fixed-length array elements.
-    // If `componentCount` is NOT defined, it's a VARIABLE-length array
-    typeof classProperty.componentCount === "undefined" && // `arrayOffsetBufferView` is an index of the buffer view containing offsets for variable-length arrays.
-    typeof propertyTableProperty.arrayOffsetBufferView !== "undefined") {
-      return getOffsetsForProperty(
-        scenegraph,
-        propertyTableProperty.arrayOffsetBufferView,
-        propertyTableProperty.offsetType || "UINT32",
-        // offsetType is used both for stringOffsetBufferView and arrayOffsetBufferView
-        numberOfElements
-      );
-    }
-    return null;
-  }
-  function getStringOffsetsForProperty2(scenegraph, classProperty, propertyTableProperty, numberOfElements) {
-    if (typeof propertyTableProperty.stringOffsetBufferView !== "undefined") {
-      return getOffsetsForProperty(
-        scenegraph,
-        propertyTableProperty.stringOffsetBufferView,
-        propertyTableProperty.offsetType || "UINT32",
-        // offsetType is used both for stringOffsetBufferView and arrayOffsetBufferView
-        numberOfElements
-      );
-    }
-    return null;
-  }
-  function isNumericProperty(schemaProperty) {
-    const types = [
-      "UINT8",
-      "INT16",
-      "UINT16",
-      "INT32",
-      "UINT32",
-      "INT64",
-      "UINT64",
-      "FLOAT32",
-      "FLOAT64"
-    ];
-    return types.includes(schemaProperty.type) || typeof schemaProperty.componentType !== "undefined" && types.includes(schemaProperty.componentType);
-  }
-  function getPropertyDataNumeric2(classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
-    const isArray2 = classProperty.type === "ARRAY";
-    const arrayCount = classProperty.componentCount;
-    const attributeType = "SCALAR";
-    const componentType = classProperty.componentType || classProperty.type;
-    const elementSize = getArrayElementByteSize(attributeType, componentType);
-    const elementCount = valuesDataBytes.byteLength / elementSize;
-    const valuesData = convertRawBufferToMetadataArray(valuesDataBytes, attributeType, componentType, elementCount);
-    if (isArray2) {
-      if (arrayOffsets) {
-        return parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
-      }
-      if (arrayCount) {
-        return parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
-      }
-      return [];
+    const Construct = COMPONENT_TYPE_TO_ARRAY_CONSTRUCTOR[componentType];
+    if (!Construct) {
+      throw new Error("Illegal component type");
     }
-    return valuesData;
+    return new Construct(numberArray);
   }
-  function getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName) {
-    const json = scenegraph.gltf.json;
-    if (!json.meshes) {
-      return [];
+  function createPropertyDataString(strings) {
+    const utf8Encode = new TextEncoder();
+    const arr = [];
+    let len5 = 0;
+    for (const str7 of strings) {
+      const uint8Array = utf8Encode.encode(str7);
+      len5 += uint8Array.length;
+      arr.push(uint8Array);
     }
-    const featureTextureTable = [];
-    for (const mesh of json.meshes) {
-      for (const primitive of mesh.primitives) {
-        processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive);
-      }
+    const strArray = new Uint8Array(len5);
+    const strOffsets = [];
+    let offset = 0;
+    for (const str7 of arr) {
+      strArray.set(str7, offset);
+      strOffsets.push(offset);
+      offset += str7.length;
     }
-    return featureTextureTable;
+    strOffsets.push(offset);
+    const stringOffsetsTypedArray = new Uint32Array(strOffsets);
+    return { stringData: strArray, stringOffsets: stringOffsetsTypedArray };
   }
-  function processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive) {
-    const textureInfoTopLevel = {
-      channels: featureTextureProperty.channels,
-      ...featureTextureProperty.texture
-    };
-    const propertyData = getPrimitiveTextureData(scenegraph, textureInfoTopLevel, primitive);
-    if (!propertyData) {
-      return;
-    }
-    primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTextureTable, primitive);
+  function createBufferView(typedArray, scenegraph) {
+    scenegraph.gltf.buffers.push({
+      arrayBuffer: ensureArrayBuffer(typedArray.buffer),
+      byteOffset: typedArray.byteOffset,
+      byteLength: typedArray.byteLength
+    });
+    return scenegraph.addBufferView(typedArray);
   }
 
-  // ../../node_modules/@loaders.gl/gltf/dist/lib/utils/version.js
-  var VERSION10 = true ? "4.4.0-alpha.16" : "latest";
-
-  // ../../node_modules/@loaders.gl/gltf/node_modules/@loaders.gl/textures/dist/lib/utils/version.js
-  var VERSION11 = true ? "4.4.0-alpha.16" : "latest";
-
-  // ../../node_modules/@loaders.gl/gltf/node_modules/@loaders.gl/textures/dist/lib/parsers/basis-module-loader.js
-  var BASIS_EXTERNAL_LIBRARIES = {
-    /** Basis transcoder, javascript wrapper part */
-    TRANSCODER: "basis_transcoder.js",
-    /** Basis transcoder, compiled web assembly part */
-    TRANSCODER_WASM: "basis_transcoder.wasm",
-    /** Basis encoder, javascript wrapper part */
-    ENCODER: "basis_encoder.js",
-    /** Basis encoder, compiled web assembly part */
-    ENCODER_WASM: "basis_encoder.wasm"
-  };
-  var loadBasisTranscoderPromise;
-  async function loadBasisTranscoderModule(options) {
-    registerJSModules(options.modules);
-    const basis = getJSModuleOrNull("basis");
-    if (basis) {
-      return basis;
-    }
-    loadBasisTranscoderPromise ||= loadBasisTranscoder(options);
-    return await loadBasisTranscoderPromise;
-  }
-  async function loadBasisTranscoder(options) {
-    let BASIS2 = null;
-    let wasmBinary = null;
-    [BASIS2, wasmBinary] = await Promise.all([
-      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER, "textures", options),
-      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER_WASM, "textures", options)
-    ]);
-    BASIS2 = BASIS2 || globalThis.BASIS;
-    return await initializeBasisTranscoderModule(BASIS2, wasmBinary);
+  // ../../node_modules/@loaders.gl/gltf/dist/lib/extensions/deprecated/EXT_feature_metadata.js
+  var EXT_feature_metadata_exports = {};
+  __export(EXT_feature_metadata_exports, {
+    decode: () => decode3,
+    name: () => name3
+  });
+  var EXT_FEATURE_METADATA_NAME = "EXT_feature_metadata";
+  var name3 = EXT_FEATURE_METADATA_NAME;
+  async function decode3(gltfData, options) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    decodeExtFeatureMetadata(scenegraph, options);
   }
-  function initializeBasisTranscoderModule(BasisModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
+  function decodeExtFeatureMetadata(scenegraph, options) {
+    if (!options.gltf?.loadBuffers) {
+      return;
     }
-    return new Promise((resolve2) => {
-      BasisModule(options).then((module) => {
-        const { BasisFile, initializeBasis } = module;
-        initializeBasis();
-        resolve2({ BasisFile });
-      });
-    });
-  }
-  var loadBasisEncoderPromise;
-  async function loadBasisEncoderModule(options) {
-    const modules = options.modules || {};
-    if (modules.basisEncoder) {
-      return modules.basisEncoder;
+    const extension = scenegraph.getExtension(EXT_FEATURE_METADATA_NAME);
+    if (!extension) {
+      return;
     }
-    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_EXTERNAL_LIBRARIES.ENCODER, "textures", options),
-      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER_WASM, "textures", options)
-    ]);
-    BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
-    return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
-  }
-  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
+    if (options.gltf?.loadImages) {
+      decodePropertyTextures2(scenegraph, extension);
     }
-    return new Promise((resolve2) => {
-      BasisEncoderModule(options).then((module) => {
-        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
-        initializeBasis();
-        resolve2({ BasisFile, KTX2File, BasisEncoder });
-      });
-    });
+    decodePropertyTables2(scenegraph, extension);
   }
-
-  // ../../node_modules/@loaders.gl/gltf/node_modules/@loaders.gl/textures/dist/lib/gl-extensions.js
-  var GL_EXTENSIONS_CONSTANTS = {
-    // WEBGL_compressed_texture_s3tc
-    COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
-    COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
-    COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
-    COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
-    // WEBGL_compressed_texture_es3
-    COMPRESSED_R11_EAC: 37488,
-    COMPRESSED_SIGNED_R11_EAC: 37489,
-    COMPRESSED_RG11_EAC: 37490,
-    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,
-    // WEBGL_compressed_texture_pvrtc
-    COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
-    COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
-    COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
-    COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
-    // WEBGL_compressed_texture_etc1
-    COMPRESSED_RGB_ETC1_WEBGL: 36196,
-    // WEBGL_compressed_texture_atc
-    COMPRESSED_RGB_ATC_WEBGL: 35986,
-    COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35987,
-    COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798,
-    // WEBGL_compressed_texture_astc
-    COMPRESSED_RGBA_ASTC_4X4_KHR: 37808,
-    COMPRESSED_RGBA_ASTC_5X4_KHR: 37809,
-    COMPRESSED_RGBA_ASTC_5X5_KHR: 37810,
-    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,
-    // EXT_texture_compression_rgtc
-    COMPRESSED_RED_RGTC1_EXT: 36283,
-    COMPRESSED_SIGNED_RED_RGTC1_EXT: 36284,
-    COMPRESSED_RED_GREEN_RGTC2_EXT: 36285,
-    COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 36286,
-    // WEBGL_compressed_texture_s3tc_srgb
-    COMPRESSED_SRGB_S3TC_DXT1_EXT: 35916,
-    COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 35917,
-    COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 35918,
-    COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 35919
-  };
-
-  // ../../node_modules/@loaders.gl/gltf/node_modules/@loaders.gl/textures/dist/lib/utils/texture-formats.js
-  var BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
-  var WEBGL_EXTENSIONS = {
-    /* eslint-disable camelcase */
-    WEBGL_compressed_texture_s3tc: "dxt",
-    WEBGL_compressed_texture_s3tc_srgb: "dxt-srgb",
-    WEBGL_compressed_texture_etc1: "etc1",
-    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"
-    /* eslint-enable camelcase */
-  };
-  var formats = null;
-  function getSupportedGPUTextureFormats(gl) {
-    if (!formats) {
-      gl = gl || getWebGLContext() || void 0;
-      formats = /* @__PURE__ */ 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);
-          }
+  function decodePropertyTextures2(scenegraph, extension) {
+    const schema = extension.schema;
+    if (!schema) {
+      return;
+    }
+    const schemaClasses = schema.classes;
+    const { featureTextures } = extension;
+    if (schemaClasses && featureTextures) {
+      for (const schemaName in schemaClasses) {
+        const schemaClass = schemaClasses[schemaName];
+        const featureTexture = findFeatureTextureByClass(featureTextures, schemaName);
+        if (featureTexture) {
+          handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass);
         }
       }
     }
-    return formats;
-  }
-  function getWebGLContext() {
-    try {
-      const canvas = document.createElement("canvas");
-      return canvas.getContext("webgl");
-    } catch (error) {
-      return null;
-    }
-  }
-
-  // ../../node_modules/@loaders.gl/gltf/node_modules/@loaders.gl/textures/dist/lib/parsers/parse-ktx.js
-  var KTX2_ID = [
-    // '´', 'K', 'T', 'X', '2', '0', 'ª', '\r', '\n', '\x1A', '\n'
-    171,
-    75,
-    84,
-    88,
-    32,
-    50,
-    48,
-    187,
-    13,
-    10,
-    26,
-    10
-  ];
-  function isKTX(data) {
-    const id = new Uint8Array(data);
-    const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || // '´'
-    id[1] !== KTX2_ID[1] || // 'K'
-    id[2] !== KTX2_ID[2] || // 'T'
-    id[3] !== KTX2_ID[3] || // 'X'
-    id[4] !== KTX2_ID[4] || // ' '
-    id[5] !== KTX2_ID[5] || // '2'
-    id[6] !== KTX2_ID[6] || // '0'
-    id[7] !== KTX2_ID[7] || // 'ª'
-    id[8] !== KTX2_ID[8] || // '\r'
-    id[9] !== KTX2_ID[9] || // '\n'
-    id[10] !== KTX2_ID[10] || // '\x1A'
-    id[11] !== KTX2_ID[11];
-    return !notKTX;
   }
-
-  // ../../node_modules/@loaders.gl/gltf/node_modules/@loaders.gl/textures/dist/lib/parsers/parse-basis.js
-  var 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 }
-  };
-  async function parseBasis(data, options = {}) {
-    if (!options.basis?.containerFormat || options.basis.containerFormat === "auto") {
-      if (isKTX(data)) {
-        const fileConstructors = await loadBasisEncoderModule(options?.core || {});
-        return parseKTX2File(fileConstructors.KTX2File, data, options);
-      }
-      const { BasisFile } = await loadBasisTranscoderModule(options?.core || {});
-      return parseBasisFile(BasisFile, data, options);
+  function decodePropertyTables2(scenegraph, extension) {
+    const schema = extension.schema;
+    if (!schema) {
+      return;
     }
-    switch (options.basis.module) {
-      case "encoder":
-        const fileConstructors = await loadBasisEncoderModule(options?.core || {});
-        switch (options.basis.containerFormat) {
-          case "ktx2":
-            return parseKTX2File(fileConstructors.KTX2File, data, options);
-          case "basis":
-          default:
-            return parseBasisFile(fileConstructors.BasisFile, data, options);
+    const schemaClasses = schema.classes;
+    const propertyTables = extension.featureTables;
+    if (schemaClasses && propertyTables) {
+      for (const schemaName in schemaClasses) {
+        const propertyTable = findPropertyTableByClass2(propertyTables, schemaName);
+        if (propertyTable) {
+          processPropertyTable2(scenegraph, schema, propertyTable);
         }
-      case "transcoder":
-      default:
-        const { BasisFile } = await loadBasisTranscoderModule(options.core || {});
-        return parseBasisFile(BasisFile, data, options);
+      }
     }
   }
-  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));
-        }
-        images.push(levels);
+  function findPropertyTableByClass2(propertyTables, schemaClassName) {
+    for (const propertyTableName in propertyTables) {
+      const propertyTable = propertyTables[propertyTableName];
+      if (propertyTable.class === schemaClassName) {
+        return propertyTable;
       }
-      return images;
-    } finally {
-      basisFile.close();
-      basisFile.delete();
     }
+    return null;
   }
-  function transcodeImage(basisFile, imageIndex, levelIndex, options) {
-    const width = basisFile.getImageWidth(imageIndex, levelIndex);
-    const height = basisFile.getImageHeight(imageIndex, levelIndex);
-    const hasAlpha = basisFile.getHasAlpha(
-      /* imageIndex, levelIndex */
-    );
-    const { compressed, format, basisFormat } = getBasisOptions(options, hasAlpha);
-    const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
-    const decodedData = new Uint8Array(decodedSize);
-    if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
-      throw new Error("failed to start Basis transcoding");
+  function findFeatureTextureByClass(featureTextures, schemaClassName) {
+    for (const featureTexturesName in featureTextures) {
+      const featureTable = featureTextures[featureTexturesName];
+      if (featureTable.class === schemaClassName) {
+        return featureTable;
+      }
     }
-    return {
-      // standard loaders.gl image category payload
-      width,
-      height,
-      data: decodedData,
-      compressed,
-      format,
-      // Additional fields
-      // Add levelSize field.
-      hasAlpha
-    };
+    return null;
   }
-  function parseKTX2File(KTX2File, data, options) {
-    const ktx2File = new KTX2File(new Uint8Array(data));
-    try {
-      if (!ktx2File.startTranscoding()) {
-        throw new Error("failed to start KTX2 transcoding");
+  function processPropertyTable2(scenegraph, schema, propertyTable) {
+    if (!propertyTable.class) {
+      return;
+    }
+    const schemaClass = schema.classes?.[propertyTable.class];
+    if (!schemaClass) {
+      throw new Error(`Incorrect data in the EXT_structural_metadata extension: no schema class with name ${propertyTable.class}`);
+    }
+    const numberOfElements = propertyTable.count;
+    for (const propertyName in schemaClass.properties) {
+      const classProperty = schemaClass.properties[propertyName];
+      const propertyTableProperty = propertyTable.properties?.[propertyName];
+      if (propertyTableProperty) {
+        const data = getPropertyDataFromBinarySource2(scenegraph, schema, classProperty, numberOfElements, propertyTableProperty);
+        propertyTableProperty.data = data;
       }
-      const levelsCount = ktx2File.getLevels();
-      const levels = [];
-      for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
-        levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
+    }
+  }
+  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;
       }
-      return [levels];
-    } finally {
-      ktx2File.close();
-      ktx2File.delete();
     }
   }
-  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
-      /* channel1 */
-    )) {
-      throw new Error("Failed to transcode KTX2 image");
+  function getPropertyDataFromBinarySource2(scenegraph, schema, classProperty, numberOfFeatures, featureTableProperty) {
+    let data = [];
+    const bufferView = featureTableProperty.bufferView;
+    const dataArray = scenegraph.getTypedArrayForBufferView(bufferView);
+    const arrayOffsets = getArrayOffsetsForProperty2(scenegraph, classProperty, featureTableProperty, numberOfFeatures);
+    const stringOffsets = getStringOffsetsForProperty2(scenegraph, classProperty, featureTableProperty, numberOfFeatures);
+    if (classProperty.type === "STRING" || classProperty.componentType === "STRING") {
+      data = getPropertyDataString(numberOfFeatures, dataArray, arrayOffsets, stringOffsets);
+    } else if (isNumericProperty(classProperty)) {
+      data = getPropertyDataNumeric2(classProperty, numberOfFeatures, dataArray, arrayOffsets);
     }
-    return {
-      // standard loaders.gl image category payload
-      width,
-      height,
-      data: decodedData,
-      compressed,
-      // Additional fields
-      levelSize: decodedSize,
-      hasAlpha: alphaFlag,
-      format
-    };
+    return data;
   }
-  function getBasisOptions(options, hasAlpha) {
-    let format = options.basis?.format;
-    if (format === "auto") {
-      format = selectSupportedBasisFormat();
+  function getArrayOffsetsForProperty2(scenegraph, classProperty, propertyTableProperty, numberOfElements) {
+    if (classProperty.type === "ARRAY" && // `componentCount` is a number of fixed-length array elements.
+    // If `componentCount` is NOT defined, it's a VARIABLE-length array
+    typeof classProperty.componentCount === "undefined" && // `arrayOffsetBufferView` is an index of the buffer view containing offsets for variable-length arrays.
+    typeof propertyTableProperty.arrayOffsetBufferView !== "undefined") {
+      return getOffsetsForProperty(
+        scenegraph,
+        propertyTableProperty.arrayOffsetBufferView,
+        propertyTableProperty.offsetType || "UINT32",
+        // offsetType is used both for stringOffsetBufferView and arrayOffsetBufferView
+        numberOfElements
+      );
     }
-    if (typeof format === "object") {
-      format = hasAlpha ? format.alpha : format.noAlpha;
+    return null;
+  }
+  function getStringOffsetsForProperty2(scenegraph, classProperty, propertyTableProperty, numberOfElements) {
+    if (typeof propertyTableProperty.stringOffsetBufferView !== "undefined") {
+      return getOffsetsForProperty(
+        scenegraph,
+        propertyTableProperty.stringOffsetBufferView,
+        propertyTableProperty.offsetType || "UINT32",
+        // offsetType is used both for stringOffsetBufferView and arrayOffsetBufferView
+        numberOfElements
+      );
     }
-    format = format.toLowerCase();
-    return OutputFormat[format];
+    return null;
   }
-  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 isNumericProperty(schemaProperty) {
+    const types = [
+      "UINT8",
+      "INT16",
+      "UINT16",
+      "INT32",
+      "UINT32",
+      "INT64",
+      "UINT64",
+      "FLOAT32",
+      "FLOAT64"
+    ];
+    return types.includes(schemaProperty.type) || typeof schemaProperty.componentType !== "undefined" && types.includes(schemaProperty.componentType);
+  }
+  function getPropertyDataNumeric2(classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
+    const isArray2 = classProperty.type === "ARRAY";
+    const arrayCount = classProperty.componentCount;
+    const attributeType = "SCALAR";
+    const componentType = classProperty.componentType || classProperty.type;
+    const elementSize = getArrayElementByteSize(attributeType, componentType);
+    const elementCount = valuesDataBytes.byteLength / elementSize;
+    const valuesData = convertRawBufferToMetadataArray(valuesDataBytes, attributeType, componentType, elementCount);
+    if (isArray2) {
+      if (arrayOffsets) {
+        return parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
+      }
+      if (arrayCount) {
+        return parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
+      }
+      return [];
     }
-    return "rgb565";
+    return valuesData;
   }
-
-  // ../../node_modules/@loaders.gl/gltf/node_modules/@loaders.gl/textures/dist/basis-loader.js
-  var BasisWorkerLoader = {
-    dataType: null,
-    batchType: null,
-    name: "Basis",
-    id: "basis",
-    module: "textures",
-    version: VERSION11,
-    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"
+  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);
       }
     }
-  };
-  var BasisLoader = {
-    ...BasisWorkerLoader,
-    parse: parseBasis
-  };
+    return featureTextureTable;
+  }
+  function processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive) {
+    const textureInfoTopLevel = {
+      channels: featureTextureProperty.channels,
+      ...featureTextureProperty.texture
+    };
+    const propertyData = getPrimitiveTextureData(scenegraph, textureInfoTopLevel, primitive);
+    if (!propertyData) {
+      return;
+    }
+    primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTextureTable, primitive);
+  }
+
+  // ../../node_modules/@loaders.gl/gltf/dist/lib/utils/version.js
+  var VERSION11 = true ? "4.4.0-alpha.18" : "latest";
 
   // ../../node_modules/@loaders.gl/gltf/dist/lib/parsers/parse-glb.js
   var LITTLE_ENDIAN2 = true;
@@ -25587,8 +25764,7 @@ void main(void) {
     const strictOptions = options;
     const gltfOptions = {
       ...strictOptions,
-      core: { ...strictOptions?.core, mimeType: image.mimeType },
-      basis: strictOptions.basis || { format: selectSupportedBasisFormat() }
+      core: { ...strictOptions?.core, mimeType: image.mimeType }
     };
     let parsedImage = await parseFromContext(arrayBuffer, [ImageLoader, BasisLoader], gltfOptions, context);
     if (parsedImage && parsedImage[0]) {
@@ -25612,7 +25788,7 @@ void main(void) {
     name: "glTF",
     id: "gltf",
     module: "gltf",
-    version: VERSION10,
+    version: VERSION11,
     extensions: ["gltf", "glb"],
     mimeTypes: ["model/gltf+json", "model/gltf-binary"],
     text: true,
@@ -26377,7 +26553,7 @@ void main(void) {
     id: "3d-tiles-subtree",
     name: "3D Tiles Subtree",
     module: "3d-tiles",
-    version: VERSION8,
+    version: VERSION9,
     extensions: ["subtree"],
     mimeTypes: ["application/octet-stream"],
     tests: ["subtree"],
@@ -27964,7 +28140,7 @@ void main(void) {
     id: "3d-tiles",
     name: "3D Tiles",
     module: "3d-tiles",
-    version: VERSION8,
+    version: VERSION9,
     extensions: ["cmpt", "pnts", "b3dm", "i3dm"],
     mimeTypes: ["application/octet-stream"],
     tests: ["cmpt", "pnts", "b3dm", "i3dm"],
@@ -29298,7 +29474,7 @@ void main(void) {
   }
 
   // ../../node_modules/@loaders.gl/terrain/dist/lib/utils/version.js
-  var VERSION12 = true ? "4.4.0-alpha.16" : "latest";
+  var VERSION12 = true ? "4.4.0-alpha.18" : "latest";
 
   // ../../node_modules/@loaders.gl/terrain/dist/terrain-loader.js
   var TerrainLoader = {
@@ -31170,7 +31346,7 @@ void main(void) {
   };
 
   // ../../node_modules/@loaders.gl/mvt/dist/mvt-loader.js
-  var VERSION13 = true ? "4.4.0-alpha.16" : "latest";
+  var VERSION13 = true ? "4.4.0-alpha.18" : "latest";
   var MVTWorkerLoader = {
     ...MVTFormat,
     dataType: null,