@deck.gl/geo-layers 9.3.4 → 9.3.6

package/dist/dist.dev.js

@@ -11232,7 +11232,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/xml/dist/xml-loader.js
-  var VERSION = true ? "4.4.1" : "latest";
+  var VERSION = true ? "4.4.3" : "latest";
   var XMLLoader = {
     dataType: null,
     batchType: null,
@@ -11815,7 +11815,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.1" : "latest";
+  var VERSION3 = true ? "4.4.3" : "latest";
   var version = VERSION3[0] >= "0" && VERSION3[0] <= "9" ? `v${VERSION3}` : "";
   function createLog() {
     const log8 = new ProbeLog({ id: "loaders.gl" });
@@ -11870,7 +11870,7 @@ var __exports__ = (() => {
         globalThis._loadersgl_.version = NPM_TAG;
         warningIssued = true;
       } else {
-        globalThis._loadersgl_.version = "4.4.1";
+        globalThis._loadersgl_.version = "4.4.3";
       }
     }
     return globalThis._loadersgl_.version;
@@ -12716,7 +12716,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/wms/dist/wms-error-loader.js
-  var VERSION5 = true ? "4.4.1" : "latest";
+  var VERSION5 = true ? "4.4.3" : "latest";
   var WMSErrorLoader = {
     dataType: null,
     batchType: null,
@@ -12995,7 +12995,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/wms/dist/wms-capabilities-loader.js
-  var VERSION6 = true ? "4.4.1" : "latest";
+  var VERSION6 = true ? "4.4.3" : "latest";
   var WMSCapabilitiesLoader = {
     dataType: null,
     batchType: null,
@@ -13068,7 +13068,7 @@ var __exports__ = (() => {
   };
 
   // ../../node_modules/@loaders.gl/images/dist/lib/utils/version.js
-  var VERSION7 = true ? "4.4.1" : "latest";
+  var VERSION7 = true ? "4.4.3" : "latest";
 
   // ../../node_modules/@loaders.gl/images/dist/lib/category-api/image-type.js
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -16586,591 +16586,6 @@ out float vTime;
   var import_layers8 = __toESM(require_layers(), 1);
   var import_mesh_layers2 = __toESM(require_mesh_layers(), 1);
 
-  // ../../node_modules/@loaders.gl/textures/dist/lib/utils/version.js
-  var VERSION8 = true ? "4.4.1" : "latest";
-
-  // ../../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);
-  }
-  function initializeBasisTranscoderModule(BasisModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
-    }
-    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;
-    }
-    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;
-    }
-    return new Promise((resolve2) => {
-      BasisEncoderModule(options).then((module) => {
-        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
-        initializeBasis();
-        resolve2({ BasisFile, KTX2File, BasisEncoder });
-      });
-    });
-  }
-
-  // ../../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-rgb-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-rgb2unorm-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 basisTranscodingLock = Promise.resolve();
-  var BASIS_FORMAT_TO_OUTPUT_OPTIONS = {
-    etc1: {
-      basisFormat: 0,
-      compressed: true,
-      format: GL_COMPRESSED_RGB_ETC1_WEBGL,
-      textureFormat: "etc1-rgb-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 withBasisTranscodingLock(transcode) {
-    const previousLock = basisTranscodingLock;
-    let releaseLock;
-    basisTranscodingLock = new Promise((resolve2) => {
-      releaseLock = resolve2;
-    });
-    await previousLock;
-    try {
-      return await transcode();
-    } finally {
-      releaseLock();
-    }
-  }
-  async function parseBasis(data, options = {}) {
-    const loadLibraryOptions = extractLoadLibraryOptions(options);
-    return await withBasisTranscodingLock(async () => {
-      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-rgb2unorm-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-rgb-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_core21 = __toESM(require_core3(), 1);
 
@@ -24065,7 +23480,7 @@ void main(void) {
   };
 
   // ../../node_modules/@loaders.gl/3d-tiles/dist/lib/utils/version.js
-  var VERSION9 = true ? "4.4.1" : "latest";
+  var VERSION8 = true ? "4.4.3" : "latest";
 
   // ../../node_modules/@loaders.gl/3d-tiles/dist/lib/constants.js
   var TILE3D_TYPE = {
@@ -24184,7 +23599,7 @@ void main(void) {
   }
 
   // ../../node_modules/@loaders.gl/draco/dist/lib/utils/version.js
-  var VERSION10 = true ? "4.4.1" : "latest";
+  var VERSION9 = true ? "4.4.3" : "latest";
 
   // ../../node_modules/@loaders.gl/schema-utils/dist/lib/schema/data-type.js
   function getDataTypeFromTypedArray(array) {
@@ -24755,7 +24170,7 @@ void main(void) {
     id: "draco",
     module: "draco",
     // shapes: ['mesh'],
-    version: VERSION10,
+    version: VERSION9,
     worker: true,
     extensions: ["drc"],
     mimeTypes: ["application/octet-stream"],
@@ -26195,631 +25610,1032 @@ void main(void) {
     getRequiredExtensions() {
       return this.json.extensionsRequired || [];
     }
-    getUsedExtensions() {
-      return this.json.extensionsUsed || [];
+    getUsedExtensions() {
+      return this.json.extensionsUsed || [];
+    }
+    getRemovedExtensions() {
+      return this.json.extensionsRemoved || [];
+    }
+    getObjectExtension(object, extensionName) {
+      const extensions = object.extensions || {};
+      return extensions[extensionName];
+    }
+    getScene(index) {
+      return this.getObject("scenes", index);
+    }
+    getNode(index) {
+      return this.getObject("nodes", index);
+    }
+    getSkin(index) {
+      return this.getObject("skins", index);
+    }
+    getMesh(index) {
+      return this.getObject("meshes", index);
+    }
+    getMaterial(index) {
+      return this.getObject("materials", index);
+    }
+    getAccessor(index) {
+      return this.getObject("accessors", index);
+    }
+    // getCamera(index: number): object | null {
+    //   return null; // TODO: fix thi: object  as null;
+    // }
+    getTexture(index) {
+      return this.getObject("textures", index);
+    }
+    getSampler(index) {
+      return this.getObject("samplers", index);
+    }
+    getImage(index) {
+      return this.getObject("images", index);
+    }
+    getBufferView(index) {
+      return this.getObject("bufferViews", index);
+    }
+    getBuffer(index) {
+      return this.getObject("buffers", index);
+    }
+    getObject(array, index) {
+      if (typeof index === "object") {
+        return index;
+      }
+      const object = this.json[array] && this.json[array][index];
+      if (!object) {
+        throw new Error(`glTF file error: Could not find ${array}[${index}]`);
+      }
+      return object;
+    }
+    /**
+     * Accepts buffer view index or buffer view object
+     * @returns a `Uint8Array`
+     */
+    getTypedArrayForBufferView(bufferView) {
+      bufferView = this.getBufferView(bufferView);
+      const bufferIndex = bufferView.buffer;
+      const binChunk = this.gltf.buffers[bufferIndex];
+      assert8(binChunk);
+      const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
+      return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
+    }
+    /** Accepts accessor index or accessor object
+     * @returns a typed array with type that matches the types
+     */
+    getTypedArrayForAccessor(accessor) {
+      const gltfAccessor = this.getAccessor(accessor);
+      return getTypedArrayForAccessor(this.gltf.json, this.gltf.buffers, gltfAccessor);
+    }
+    /** accepts accessor index or accessor object
+     * returns a `Uint8Array`
+     */
+    getTypedArrayForImageData(image) {
+      image = this.getAccessor(image);
+      const bufferView = this.getBufferView(image.bufferView);
+      const buffer = this.getBuffer(bufferView.buffer);
+      const arrayBuffer = buffer.data;
+      const byteOffset = bufferView.byteOffset || 0;
+      return new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
+    }
+    // MODIFERS
+    /**
+     * Add an extra application-defined key to the top-level data structure
+     */
+    addApplicationData(key, data) {
+      this.json[key] = data;
+      return this;
+    }
+    /**
+     * `extras` - Standard GLTF field for storing application specific data
+     */
+    addExtraData(key, data) {
+      this.json.extras = this.json.extras || {};
+      this.json.extras[key] = data;
+      return this;
+    }
+    addObjectExtension(object, extensionName, data) {
+      object.extensions = object.extensions || {};
+      object.extensions[extensionName] = data;
+      this.registerUsedExtension(extensionName);
+      return this;
+    }
+    setObjectExtension(object, extensionName, data) {
+      const extensions = object.extensions || {};
+      extensions[extensionName] = data;
+    }
+    removeObjectExtension(object, extensionName) {
+      const extensions = object?.extensions || {};
+      if (extensions[extensionName]) {
+        this.json.extensionsRemoved = this.json.extensionsRemoved || [];
+        const extensionsRemoved = this.json.extensionsRemoved;
+        if (!extensionsRemoved.includes(extensionName)) {
+          extensionsRemoved.push(extensionName);
+        }
+      }
+      delete extensions[extensionName];
+    }
+    /**
+     * Add to standard GLTF top level extension object, mark as used
+     */
+    addExtension(extensionName, extensionData = {}) {
+      assert8(extensionData);
+      this.json.extensions = this.json.extensions || {};
+      this.json.extensions[extensionName] = extensionData;
+      this.registerUsedExtension(extensionName);
+      return extensionData;
+    }
+    /**
+     * Standard GLTF top level extension object, mark as used and required
+     */
+    addRequiredExtension(extensionName, extensionData = {}) {
+      assert8(extensionData);
+      this.addExtension(extensionName, extensionData);
+      this.registerRequiredExtension(extensionName);
+      return extensionData;
+    }
+    /**
+     * Add extensionName to list of used extensions
+     */
+    registerUsedExtension(extensionName) {
+      this.json.extensionsUsed = this.json.extensionsUsed || [];
+      if (!this.json.extensionsUsed.find((ext) => ext === extensionName)) {
+        this.json.extensionsUsed.push(extensionName);
+      }
     }
-    getRemovedExtensions() {
-      return this.json.extensionsRemoved || [];
+    /**
+     * Add extensionName to list of required extensions
+     */
+    registerRequiredExtension(extensionName) {
+      this.registerUsedExtension(extensionName);
+      this.json.extensionsRequired = this.json.extensionsRequired || [];
+      if (!this.json.extensionsRequired.find((ext) => ext === extensionName)) {
+        this.json.extensionsRequired.push(extensionName);
+      }
     }
-    getObjectExtension(object, extensionName) {
-      const extensions = object.extensions || {};
-      return extensions[extensionName];
+    /**
+     * Removes an extension from the top-level list
+     */
+    removeExtension(extensionName) {
+      if (this.json.extensions?.[extensionName]) {
+        this.json.extensionsRemoved = this.json.extensionsRemoved || [];
+        const extensionsRemoved = this.json.extensionsRemoved;
+        if (!extensionsRemoved.includes(extensionName)) {
+          extensionsRemoved.push(extensionName);
+        }
+      }
+      if (this.json.extensions) {
+        delete this.json.extensions[extensionName];
+      }
+      if (this.json.extensionsRequired) {
+        this._removeStringFromArray(this.json.extensionsRequired, extensionName);
+      }
+      if (this.json.extensionsUsed) {
+        this._removeStringFromArray(this.json.extensionsUsed, extensionName);
+      }
     }
-    getScene(index) {
-      return this.getObject("scenes", index);
+    /**
+     *  Set default scene which is to be displayed at load time
+     */
+    setDefaultScene(sceneIndex) {
+      this.json.scene = sceneIndex;
     }
-    getNode(index) {
-      return this.getObject("nodes", index);
+    /**
+     * @todo: add more properties for scene initialization:
+     *   name`, `extensions`, `extras`
+     *   https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-scene
+     */
+    addScene(scene) {
+      const { nodeIndices } = scene;
+      this.json.scenes = this.json.scenes || [];
+      this.json.scenes.push({ nodes: nodeIndices });
+      return this.json.scenes.length - 1;
     }
-    getSkin(index) {
-      return this.getObject("skins", index);
+    /**
+     * @todo: add more properties for node initialization:
+     *   `name`, `extensions`, `extras`, `camera`, `children`, `skin`, `rotation`, `scale`, `translation`, `weights`
+     *   https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#node
+     */
+    addNode(node) {
+      const { meshIndex, matrix } = node;
+      this.json.nodes = this.json.nodes || [];
+      const nodeData = { mesh: meshIndex };
+      if (matrix) {
+        nodeData.matrix = matrix;
+      }
+      this.json.nodes.push(nodeData);
+      return this.json.nodes.length - 1;
     }
-    getMesh(index) {
-      return this.getObject("meshes", index);
+    /** Adds a mesh to the json part */
+    addMesh(mesh) {
+      const { attributes, indices, material, mode = 4 } = mesh;
+      const accessors = this._addAttributes(attributes);
+      const glTFMesh = {
+        primitives: [
+          {
+            attributes: accessors,
+            mode
+          }
+        ]
+      };
+      if (indices) {
+        const indicesAccessor = this._addIndices(indices);
+        glTFMesh.primitives[0].indices = indicesAccessor;
+      }
+      if (Number.isFinite(material)) {
+        glTFMesh.primitives[0].material = material;
+      }
+      this.json.meshes = this.json.meshes || [];
+      this.json.meshes.push(glTFMesh);
+      return this.json.meshes.length - 1;
     }
-    getMaterial(index) {
-      return this.getObject("materials", index);
+    addPointCloud(attributes) {
+      const accessorIndices = this._addAttributes(attributes);
+      const glTFMesh = {
+        primitives: [
+          {
+            attributes: accessorIndices,
+            mode: 0
+            // GL.POINTS
+          }
+        ]
+      };
+      this.json.meshes = this.json.meshes || [];
+      this.json.meshes.push(glTFMesh);
+      return this.json.meshes.length - 1;
     }
-    getAccessor(index) {
-      return this.getObject("accessors", index);
+    /**
+     * Adds a binary image. Builds glTF "JSON metadata" and saves buffer reference
+     * Buffer will be copied into BIN chunk during "pack"
+     * Currently encodes as glTF image
+     * @param imageData
+     * @param mimeType
+     */
+    addImage(imageData, mimeTypeOpt) {
+      const metadata = getBinaryImageMetadata(imageData);
+      const mimeType = mimeTypeOpt || metadata?.mimeType;
+      const bufferViewIndex = this.addBufferView(imageData);
+      const glTFImage = {
+        bufferView: bufferViewIndex,
+        mimeType
+      };
+      this.json.images = this.json.images || [];
+      this.json.images.push(glTFImage);
+      return this.json.images.length - 1;
     }
-    // getCamera(index: number): object | null {
-    //   return null; // TODO: fix thi: object  as null;
-    // }
-    getTexture(index) {
-      return this.getObject("textures", index);
+    /**
+     * Add one untyped source buffer, create a matching glTF `bufferView`, and return its index
+     * @param buffer
+     */
+    addBufferView(buffer, bufferIndex = 0, byteOffset = this.byteLength) {
+      const byteLength = buffer.byteLength;
+      assert8(Number.isFinite(byteLength));
+      this.sourceBuffers = this.sourceBuffers || [];
+      this.sourceBuffers.push(buffer);
+      const glTFBufferView = {
+        buffer: bufferIndex,
+        // Write offset from the start of the binary body
+        byteOffset,
+        byteLength
+      };
+      this.byteLength += padToNBytes(byteLength, 4);
+      this.json.bufferViews = this.json.bufferViews || [];
+      this.json.bufferViews.push(glTFBufferView);
+      return this.json.bufferViews.length - 1;
     }
-    getSampler(index) {
-      return this.getObject("samplers", index);
+    /**
+     * Adds an accessor to a bufferView
+     * @param bufferViewIndex
+     * @param accessor
+     */
+    addAccessor(bufferViewIndex, accessor) {
+      const glTFAccessor = {
+        bufferView: bufferViewIndex,
+        // @ts-ignore
+        type: getAccessorTypeFromSize(accessor.size),
+        // @ts-ignore
+        componentType: accessor.componentType,
+        // @ts-ignore
+        count: accessor.count,
+        // @ts-ignore
+        max: accessor.max,
+        // @ts-ignore
+        min: accessor.min
+      };
+      this.json.accessors = this.json.accessors || [];
+      this.json.accessors.push(glTFAccessor);
+      return this.json.accessors.length - 1;
     }
-    getImage(index) {
-      return this.getObject("images", index);
+    /**
+     * Add a binary buffer. Builds glTF "JSON metadata" and saves buffer reference
+     * Buffer will be copied into BIN chunk during "pack"
+     * Currently encodes buffers as glTF accessors, but this could be optimized
+     * @param sourceBuffer
+     * @param accessor
+     */
+    addBinaryBuffer(sourceBuffer, accessor = { size: 3 }) {
+      const bufferViewIndex = this.addBufferView(sourceBuffer);
+      let minMax = { min: accessor.min, max: accessor.max };
+      if (!minMax.min || !minMax.max) {
+        minMax = this._getAccessorMinMax(sourceBuffer, accessor.size);
+      }
+      const accessorDefaults = {
+        // @ts-ignore
+        size: accessor.size,
+        componentType: getComponentTypeFromArray(sourceBuffer),
+        // @ts-ignore
+        count: Math.round(sourceBuffer.length / accessor.size),
+        min: minMax.min,
+        max: minMax.max
+      };
+      return this.addAccessor(bufferViewIndex, Object.assign(accessorDefaults, accessor));
     }
-    getBufferView(index) {
-      return this.getObject("bufferViews", index);
+    /**
+     * Adds a texture to the json part
+     * @todo: add more properties for texture initialization
+     * `sampler`, `name`, `extensions`, `extras`
+     * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#texture
+     */
+    addTexture(texture) {
+      const { imageIndex } = texture;
+      const glTFTexture = {
+        source: imageIndex
+      };
+      this.json.textures = this.json.textures || [];
+      this.json.textures.push(glTFTexture);
+      return this.json.textures.length - 1;
     }
-    getBuffer(index) {
-      return this.getObject("buffers", index);
+    /** Adds a material to the json part */
+    addMaterial(pbrMaterialInfo) {
+      this.json.materials = this.json.materials || [];
+      this.json.materials.push(pbrMaterialInfo);
+      return this.json.materials.length - 1;
     }
-    getObject(array, index) {
-      if (typeof index === "object") {
-        return index;
+    /** Pack the binary chunk */
+    createBinaryChunk() {
+      const totalByteLength = this.byteLength;
+      const arrayBuffer = new ArrayBuffer(totalByteLength);
+      const targetArray = new Uint8Array(arrayBuffer);
+      let dstByteOffset = 0;
+      for (const sourceBuffer of this.sourceBuffers || []) {
+        dstByteOffset = copyToArray(sourceBuffer, targetArray, dstByteOffset);
+      }
+      if (this.json?.buffers?.[0]) {
+        this.json.buffers[0].byteLength = totalByteLength;
+      } else {
+        this.json.buffers = [{ byteLength: totalByteLength }];
       }
-      const object = this.json[array] && this.json[array][index];
-      if (!object) {
-        throw new Error(`glTF file error: Could not find ${array}[${index}]`);
+      this.gltf.binary = arrayBuffer;
+      this.sourceBuffers = [arrayBuffer];
+      this.gltf.buffers = [{ arrayBuffer, byteOffset: 0, byteLength: arrayBuffer.byteLength }];
+    }
+    // PRIVATE
+    _removeStringFromArray(array, string) {
+      let found = true;
+      while (found) {
+        const index = array.indexOf(string);
+        if (index > -1) {
+          array.splice(index, 1);
+        } else {
+          found = false;
+        }
       }
-      return object;
     }
     /**
-     * Accepts buffer view index or buffer view object
-     * @returns a `Uint8Array`
+     * Add attributes to buffers and create `attributes` object which is part of `mesh`
      */
-    getTypedArrayForBufferView(bufferView) {
-      bufferView = this.getBufferView(bufferView);
-      const bufferIndex = bufferView.buffer;
-      const binChunk = this.gltf.buffers[bufferIndex];
-      assert8(binChunk);
-      const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
-      return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
+    _addAttributes(attributes = {}) {
+      const result = {};
+      for (const attributeKey in attributes) {
+        const attributeData = attributes[attributeKey];
+        const attrName = this._getGltfAttributeName(attributeKey);
+        const accessor = this.addBinaryBuffer(attributeData.value, attributeData);
+        result[attrName] = accessor;
+      }
+      return result;
     }
-    /** Accepts accessor index or accessor object
-     * @returns a typed array with type that matches the types
+    /**
+     * Add indices to buffers
      */
-    getTypedArrayForAccessor(accessor) {
-      const gltfAccessor = this.getAccessor(accessor);
-      return getTypedArrayForAccessor(this.gltf.json, this.gltf.buffers, gltfAccessor);
+    _addIndices(indices) {
+      return this.addBinaryBuffer(indices, { size: 1 });
     }
-    /** accepts accessor index or accessor object
-     * returns a `Uint8Array`
+    /**
+     * Deduce gltf specific attribue name from input attribute name
      */
-    getTypedArrayForImageData(image) {
-      image = this.getAccessor(image);
-      const bufferView = this.getBufferView(image.bufferView);
-      const buffer = this.getBuffer(bufferView.buffer);
-      const arrayBuffer = buffer.data;
-      const byteOffset = bufferView.byteOffset || 0;
-      return new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
+    _getGltfAttributeName(attributeName) {
+      switch (attributeName.toLowerCase()) {
+        case "position":
+        case "positions":
+        case "vertices":
+          return "POSITION";
+        case "normal":
+        case "normals":
+          return "NORMAL";
+        case "color":
+        case "colors":
+          return "COLOR_0";
+        case "texcoord":
+        case "texcoords":
+          return "TEXCOORD_0";
+        default:
+          return attributeName;
+      }
     }
-    // MODIFERS
     /**
-     * Add an extra application-defined key to the top-level data structure
+     * Calculate `min` and `max` arrays of accessor according to spec:
+     * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-accessor
      */
-    addApplicationData(key, data) {
-      this.json[key] = data;
-      return this;
+    _getAccessorMinMax(buffer, size) {
+      const result = { min: null, max: null };
+      if (buffer.length < size) {
+        return result;
+      }
+      result.min = [];
+      result.max = [];
+      const initValues = buffer.subarray(0, size);
+      for (const value of initValues) {
+        result.min.push(value);
+        result.max.push(value);
+      }
+      for (let index = size; index < buffer.length; index += size) {
+        for (let componentIndex = 0; componentIndex < size; componentIndex++) {
+          result.min[0 + componentIndex] = Math.min(
+            // @ts-ignore
+            result.min[0 + componentIndex],
+            buffer[index + componentIndex]
+          );
+          result.max[0 + componentIndex] = Math.max(
+            // @ts-ignore
+            result.max[0 + componentIndex],
+            buffer[index + componentIndex]
+          );
+        }
+      }
+      return result;
+    }
+  };
+
+  // ../../node_modules/@loaders.gl/gltf/dist/lib/extensions/utils/3d-tiles-utils.js
+  function emod(n) {
+    return (n % 1 + 1) % 1;
+  }
+  var ATTRIBUTE_TYPE_TO_COMPONENTS2 = {
+    SCALAR: 1,
+    VEC2: 2,
+    VEC3: 3,
+    VEC4: 4,
+    MAT2: 4,
+    MAT3: 9,
+    MAT4: 16,
+    BOOLEAN: 1,
+    STRING: 1,
+    ENUM: 1
+  };
+  var ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY2 = {
+    INT8: Int8Array,
+    UINT8: Uint8Array,
+    INT16: Int16Array,
+    UINT16: Uint16Array,
+    INT32: Int32Array,
+    UINT32: Uint32Array,
+    INT64: BigInt64Array,
+    UINT64: BigUint64Array,
+    FLOAT32: Float32Array,
+    FLOAT64: Float64Array
+  };
+  var ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2 = {
+    INT8: 1,
+    UINT8: 1,
+    INT16: 2,
+    UINT16: 2,
+    INT32: 4,
+    UINT32: 4,
+    INT64: 8,
+    UINT64: 8,
+    FLOAT32: 4,
+    FLOAT64: 8
+  };
+  function getArrayElementByteSize(attributeType, componentType) {
+    return ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2[componentType] * ATTRIBUTE_TYPE_TO_COMPONENTS2[attributeType];
+  }
+  function getOffsetsForProperty(scenegraph, bufferViewIndex, offsetType, numberOfElements) {
+    if (offsetType !== "UINT8" && offsetType !== "UINT16" && offsetType !== "UINT32" && offsetType !== "UINT64") {
+      return null;
+    }
+    const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(bufferViewIndex);
+    const arrayOffsets = convertRawBufferToMetadataArray(
+      arrayOffsetsBytes,
+      "SCALAR",
+      // offsets consist of ONE component
+      offsetType,
+      numberOfElements + 1
+      // The number of offsets is equal to the property table `count` plus one.
+    );
+    if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {
+      return null;
+    }
+    return arrayOffsets;
+  }
+  function convertRawBufferToMetadataArray(data, attributeType, componentType, elementCount = 1) {
+    const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS2[attributeType];
+    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY2[componentType];
+    const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2[componentType];
+    const length8 = elementCount * numberOfComponents;
+    const byteLength = length8 * size;
+    let buffer = data.buffer;
+    let offset = data.byteOffset;
+    if (offset % size !== 0) {
+      const bufferArray = new Uint8Array(buffer);
+      buffer = bufferArray.slice(offset, offset + byteLength).buffer;
+      offset = 0;
+    }
+    return new ArrayType(ensureArrayBuffer(buffer), offset, length8);
+  }
+  function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
+    const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;
+    const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
+    const textureCoordinates = scenegraph.getTypedArrayForAccessor(texCoordAccessorIndex);
+    const json = scenegraph.gltf.json;
+    const textureIndex = textureInfo.index;
+    const imageIndex = json.textures?.[textureIndex]?.source;
+    if (typeof imageIndex !== "undefined") {
+      const mimeType = json.images?.[imageIndex]?.mimeType;
+      const parsedImage = scenegraph.gltf.images?.[imageIndex];
+      if (parsedImage && typeof parsedImage.width !== "undefined") {
+        const textureData = [];
+        for (let index = 0; index < textureCoordinates.length; index += 2) {
+          const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, textureInfo.channels);
+          textureData.push(value);
+        }
+        return textureData;
+      }
+    }
+    return [];
+  }
+  function primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTable, primitive) {
+    if (!propertyData?.length) {
+      return;
+    }
+    const featureIndices = [];
+    for (const texelData of propertyData) {
+      let index = featureTable.findIndex((item) => item === texelData);
+      if (index === -1) {
+        index = featureTable.push(texelData) - 1;
+      }
+      featureIndices.push(index);
+    }
+    const typedArray = new Uint32Array(featureIndices);
+    const bufferIndex = scenegraph.gltf.buffers.push({
+      arrayBuffer: typedArray.buffer,
+      byteOffset: typedArray.byteOffset,
+      byteLength: typedArray.byteLength
+    }) - 1;
+    const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
+    const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
+      size: 1,
+      componentType: getComponentTypeFromArray(typedArray),
+      count: typedArray.length
+    });
+    primitive.attributes[attributeName] = accessorIndex;
+  }
+  function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels = [0]) {
+    const CHANNELS_MAP = {
+      r: { offset: 0, shift: 0 },
+      g: { offset: 1, shift: 8 },
+      b: { offset: 2, shift: 16 },
+      a: { offset: 3, shift: 24 }
+    };
+    const u2 = textureCoordinates[index];
+    const v2 = textureCoordinates[index + 1];
+    let components = 1;
+    if (mimeType && (mimeType.indexOf("image/jpeg") !== -1 || mimeType.indexOf("image/png") !== -1))
+      components = 4;
+    const offset = coordinatesToOffset(u2, v2, parsedImage, components);
+    let value = 0;
+    for (const c2 of channels) {
+      const map2 = typeof c2 === "number" ? Object.values(CHANNELS_MAP)[c2] : CHANNELS_MAP[c2];
+      const imageOffset = offset + map2.offset;
+      const imageData = getImageData(parsedImage);
+      if (imageData.data.length <= imageOffset) {
+        throw new Error(`${imageData.data.length} <= ${imageOffset}`);
+      }
+      const imageValue = imageData.data[imageOffset];
+      value |= imageValue << map2.shift;
     }
-    /**
-     * `extras` - Standard GLTF field for storing application specific data
-     */
-    addExtraData(key, data) {
-      this.json.extras = this.json.extras || {};
-      this.json.extras[key] = data;
-      return this;
+    return value;
+  }
+  function coordinatesToOffset(u2, v2, parsedImage, componentsCount = 1) {
+    const w2 = parsedImage.width;
+    const iX = emod(u2) * (w2 - 1);
+    const indX = Math.round(iX);
+    const h = parsedImage.height;
+    const iY = emod(v2) * (h - 1);
+    const indY = Math.round(iY);
+    const components = parsedImage.components ? parsedImage.components : componentsCount;
+    const offset = (indY * w2 + indX) * components;
+    return offset;
+  }
+  function parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, valueSize) {
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+      const arrayOffset = arrayOffsets[index];
+      const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
+      if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
+        break;
+      }
+      const typedArrayOffset = arrayOffset / valueSize;
+      const elementCount = arrayByteSize / valueSize;
+      attributeValueArray.push(valuesData.slice(typedArrayOffset, typedArrayOffset + elementCount));
     }
-    addObjectExtension(object, extensionName, data) {
-      object.extensions = object.extensions || {};
-      object.extensions[extensionName] = data;
-      this.registerUsedExtension(extensionName);
-      return this;
+    return attributeValueArray;
+  }
+  function parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount) {
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+      const elementOffset = index * arrayCount;
+      attributeValueArray.push(valuesData.slice(elementOffset, elementOffset + arrayCount));
     }
-    setObjectExtension(object, extensionName, data) {
-      const extensions = object.extensions || {};
-      extensions[extensionName] = data;
+    return attributeValueArray;
+  }
+  function getPropertyDataString(numberOfElements, valuesDataBytes, arrayOffsets, stringOffsets) {
+    if (arrayOffsets) {
+      throw new Error("Not implemented - arrayOffsets for strings is specified");
     }
-    removeObjectExtension(object, extensionName) {
-      const extensions = object?.extensions || {};
-      if (extensions[extensionName]) {
-        this.json.extensionsRemoved = this.json.extensionsRemoved || [];
-        const extensionsRemoved = this.json.extensionsRemoved;
-        if (!extensionsRemoved.includes(extensionName)) {
-          extensionsRemoved.push(extensionName);
+    if (stringOffsets) {
+      const stringsArray = [];
+      const textDecoder = new TextDecoder("utf8");
+      let stringOffset = 0;
+      for (let index = 0; index < numberOfElements; index++) {
+        const stringByteSize = stringOffsets[index + 1] - stringOffsets[index];
+        if (stringByteSize + stringOffset <= valuesDataBytes.length) {
+          const stringData = valuesDataBytes.subarray(stringOffset, stringByteSize + stringOffset);
+          const stringAttribute = textDecoder.decode(stringData);
+          stringsArray.push(stringAttribute);
+          stringOffset += stringByteSize;
         }
       }
-      delete extensions[extensionName];
-    }
-    /**
-     * Add to standard GLTF top level extension object, mark as used
-     */
-    addExtension(extensionName, extensionData = {}) {
-      assert8(extensionData);
-      this.json.extensions = this.json.extensions || {};
-      this.json.extensions[extensionName] = extensionData;
-      this.registerUsedExtension(extensionName);
-      return extensionData;
+      return stringsArray;
     }
-    /**
-     * Standard GLTF top level extension object, mark as used and required
-     */
-    addRequiredExtension(extensionName, extensionData = {}) {
-      assert8(extensionData);
-      this.addExtension(extensionName, extensionData);
-      this.registerRequiredExtension(extensionName);
-      return extensionData;
+    return [];
+  }
+
+  // ../../node_modules/@loaders.gl/gltf/dist/lib/extensions/EXT_mesh_features.js
+  var EXT_MESH_FEATURES_NAME = "EXT_mesh_features";
+  var name = EXT_MESH_FEATURES_NAME;
+  async function decode(gltfData, options) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    decodeExtMeshFeatures(scenegraph, options);
+  }
+  function encode(gltfData, options) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    encodeExtMeshFeatures(scenegraph, options);
+    scenegraph.createBinaryChunk();
+    return scenegraph.gltf;
+  }
+  function decodeExtMeshFeatures(scenegraph, options) {
+    const json = scenegraph.gltf.json;
+    if (!json.meshes) {
+      return;
     }
-    /**
-     * Add extensionName to list of used extensions
-     */
-    registerUsedExtension(extensionName) {
-      this.json.extensionsUsed = this.json.extensionsUsed || [];
-      if (!this.json.extensionsUsed.find((ext) => ext === extensionName)) {
-        this.json.extensionsUsed.push(extensionName);
+    for (const mesh of json.meshes) {
+      for (const primitive of mesh.primitives) {
+        processMeshPrimitiveFeatures(scenegraph, primitive, options);
       }
     }
-    /**
-     * Add extensionName to list of required extensions
-     */
-    registerRequiredExtension(extensionName) {
-      this.registerUsedExtension(extensionName);
-      this.json.extensionsRequired = this.json.extensionsRequired || [];
-      if (!this.json.extensionsRequired.find((ext) => ext === extensionName)) {
-        this.json.extensionsRequired.push(extensionName);
-      }
+  }
+  function processMeshPrimitiveFeatures(scenegraph, primitive, options) {
+    if (!options?.gltf?.loadBuffers) {
+      return;
     }
-    /**
-     * Removes an extension from the top-level list
-     */
-    removeExtension(extensionName) {
-      if (this.json.extensions?.[extensionName]) {
-        this.json.extensionsRemoved = this.json.extensionsRemoved || [];
-        const extensionsRemoved = this.json.extensionsRemoved;
-        if (!extensionsRemoved.includes(extensionName)) {
-          extensionsRemoved.push(extensionName);
-        }
+    const extension = primitive.extensions?.[EXT_MESH_FEATURES_NAME];
+    const featureIds = extension?.featureIds;
+    if (!featureIds) {
+      return;
+    }
+    for (const featureId of featureIds) {
+      let featureIdData;
+      if (typeof featureId.attribute !== "undefined") {
+        const accessorKey = `_FEATURE_ID_${featureId.attribute}`;
+        const accessorIndex = primitive.attributes[accessorKey];
+        featureIdData = scenegraph.getTypedArrayForAccessor(accessorIndex);
+      } else if (typeof featureId.texture !== "undefined" && options?.gltf?.loadImages) {
+        featureIdData = getPrimitiveTextureData(scenegraph, featureId.texture, primitive);
+      } else {
+        featureIdData = [];
       }
-      if (this.json.extensions) {
-        delete this.json.extensions[extensionName];
+      featureId.data = featureIdData;
+    }
+  }
+  function encodeExtMeshFeatures(scenegraph, options) {
+    const meshes = scenegraph.gltf.json.meshes;
+    if (!meshes) {
+      return;
+    }
+    for (const mesh of meshes) {
+      for (const primitive of mesh.primitives) {
+        encodeExtMeshFeaturesForPrimitive(scenegraph, primitive);
       }
-      if (this.json.extensionsRequired) {
-        this._removeStringFromArray(this.json.extensionsRequired, extensionName);
+    }
+  }
+  function createExtMeshFeatures(scenegraph, primitive, featureIdArray, propertyTableIndex) {
+    if (!primitive.extensions) {
+      primitive.extensions = {};
+    }
+    let extension = primitive.extensions[EXT_MESH_FEATURES_NAME];
+    if (!extension) {
+      extension = { featureIds: [] };
+      primitive.extensions[EXT_MESH_FEATURES_NAME] = extension;
+    }
+    const { featureIds } = extension;
+    const featureId = {
+      featureCount: featureIdArray.length,
+      propertyTable: propertyTableIndex,
+      data: featureIdArray
+    };
+    featureIds.push(featureId);
+    scenegraph.addObjectExtension(primitive, EXT_MESH_FEATURES_NAME, extension);
+  }
+  function encodeExtMeshFeaturesForPrimitive(scenegraph, primitive) {
+    const extension = primitive.extensions?.[EXT_MESH_FEATURES_NAME];
+    if (!extension) {
+      return;
+    }
+    const featureIds = extension.featureIds;
+    featureIds.forEach((featureId, elementIndex) => {
+      if (featureId.data) {
+        const { accessorKey, index } = createAccessorKey(primitive.attributes);
+        const typedArray = new Uint32Array(featureId.data);
+        featureIds[elementIndex] = {
+          featureCount: typedArray.length,
+          propertyTable: featureId.propertyTable,
+          attribute: index
+        };
+        scenegraph.gltf.buffers.push({
+          arrayBuffer: typedArray.buffer,
+          byteOffset: typedArray.byteOffset,
+          byteLength: typedArray.byteLength
+        });
+        const bufferViewIndex = scenegraph.addBufferView(typedArray);
+        const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
+          size: 1,
+          componentType: getComponentTypeFromArray(typedArray),
+          count: typedArray.length
+        });
+        primitive.attributes[accessorKey] = accessorIndex;
       }
-      if (this.json.extensionsUsed) {
-        this._removeStringFromArray(this.json.extensionsUsed, extensionName);
+    });
+  }
+  function createAccessorKey(attributes) {
+    const prefix = "_FEATURE_ID_";
+    const attrs = Object.keys(attributes).filter((item) => item.indexOf(prefix) === 0);
+    let max4 = -1;
+    for (const a2 of attrs) {
+      const n = Number(a2.substring(prefix.length));
+      if (n > max4) {
+        max4 = n;
       }
     }
-    /**
-     *  Set default scene which is to be displayed at load time
-     */
-    setDefaultScene(sceneIndex) {
-      this.json.scene = sceneIndex;
+    max4++;
+    const accessorKey = `${prefix}${max4}`;
+    return { accessorKey, index: max4 };
+  }
+
+  // ../../node_modules/@loaders.gl/gltf/dist/lib/extensions/EXT_structural_metadata.js
+  var EXT_structural_metadata_exports = {};
+  __export(EXT_structural_metadata_exports, {
+    createExtStructuralMetadata: () => createExtStructuralMetadata,
+    decode: () => decode2,
+    encode: () => encode2,
+    name: () => name2
+  });
+  var EXT_STRUCTURAL_METADATA_NAME = "EXT_structural_metadata";
+  var name2 = EXT_STRUCTURAL_METADATA_NAME;
+  async function decode2(gltfData, options) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    decodeExtStructuralMetadata(scenegraph, options);
+  }
+  function encode2(gltfData, options) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    encodeExtStructuralMetadata(scenegraph, options);
+    scenegraph.createBinaryChunk();
+    return scenegraph.gltf;
+  }
+  function decodeExtStructuralMetadata(scenegraph, options) {
+    if (!options.gltf?.loadBuffers) {
+      return;
     }
-    /**
-     * @todo: add more properties for scene initialization:
-     *   name`, `extensions`, `extras`
-     *   https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-scene
-     */
-    addScene(scene) {
-      const { nodeIndices } = scene;
-      this.json.scenes = this.json.scenes || [];
-      this.json.scenes.push({ nodes: nodeIndices });
-      return this.json.scenes.length - 1;
+    const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
+    if (!extension) {
+      return;
     }
-    /**
-     * @todo: add more properties for node initialization:
-     *   `name`, `extensions`, `extras`, `camera`, `children`, `skin`, `rotation`, `scale`, `translation`, `weights`
-     *   https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#node
-     */
-    addNode(node) {
-      const { meshIndex, matrix } = node;
-      this.json.nodes = this.json.nodes || [];
-      const nodeData = { mesh: meshIndex };
-      if (matrix) {
-        nodeData.matrix = matrix;
-      }
-      this.json.nodes.push(nodeData);
-      return this.json.nodes.length - 1;
+    if (options.gltf?.loadImages) {
+      decodePropertyTextures(scenegraph, extension);
     }
-    /** Adds a mesh to the json part */
-    addMesh(mesh) {
-      const { attributes, indices, material, mode = 4 } = mesh;
-      const accessors = this._addAttributes(attributes);
-      const glTFMesh = {
-        primitives: [
-          {
-            attributes: accessors,
-            mode
-          }
-        ]
-      };
-      if (indices) {
-        const indicesAccessor = this._addIndices(indices);
-        glTFMesh.primitives[0].indices = indicesAccessor;
-      }
-      if (Number.isFinite(material)) {
-        glTFMesh.primitives[0].material = material;
+    decodePropertyTables(scenegraph, extension);
+  }
+  function decodePropertyTextures(scenegraph, extension) {
+    const propertyTextures = extension.propertyTextures;
+    const json = scenegraph.gltf.json;
+    if (propertyTextures && json.meshes) {
+      for (const mesh of json.meshes) {
+        for (const primitive of mesh.primitives) {
+          processPrimitivePropertyTextures(scenegraph, propertyTextures, primitive, extension);
+        }
       }
-      this.json.meshes = this.json.meshes || [];
-      this.json.meshes.push(glTFMesh);
-      return this.json.meshes.length - 1;
     }
-    addPointCloud(attributes) {
-      const accessorIndices = this._addAttributes(attributes);
-      const glTFMesh = {
-        primitives: [
-          {
-            attributes: accessorIndices,
-            mode: 0
-            // GL.POINTS
-          }
-        ]
-      };
-      this.json.meshes = this.json.meshes || [];
-      this.json.meshes.push(glTFMesh);
-      return this.json.meshes.length - 1;
+  }
+  function decodePropertyTables(scenegraph, extension) {
+    const schema = extension.schema;
+    if (!schema) {
+      return;
     }
-    /**
-     * Adds a binary image. Builds glTF "JSON metadata" and saves buffer reference
-     * Buffer will be copied into BIN chunk during "pack"
-     * Currently encodes as glTF image
-     * @param imageData
-     * @param mimeType
-     */
-    addImage(imageData, mimeTypeOpt) {
-      const metadata = getBinaryImageMetadata(imageData);
-      const mimeType = mimeTypeOpt || metadata?.mimeType;
-      const bufferViewIndex = this.addBufferView(imageData);
-      const glTFImage = {
-        bufferView: bufferViewIndex,
-        mimeType
-      };
-      this.json.images = this.json.images || [];
-      this.json.images.push(glTFImage);
-      return this.json.images.length - 1;
+    const schemaClasses = schema.classes;
+    const propertyTables = extension.propertyTables;
+    if (schemaClasses && propertyTables) {
+      for (const schemaName in schemaClasses) {
+        const propertyTable = findPropertyTableByClass(propertyTables, schemaName);
+        if (propertyTable) {
+          processPropertyTable(scenegraph, schema, propertyTable);
+        }
+      }
     }
-    /**
-     * Add one untyped source buffer, create a matching glTF `bufferView`, and return its index
-     * @param buffer
-     */
-    addBufferView(buffer, bufferIndex = 0, byteOffset = this.byteLength) {
-      const byteLength = buffer.byteLength;
-      assert8(Number.isFinite(byteLength));
-      this.sourceBuffers = this.sourceBuffers || [];
-      this.sourceBuffers.push(buffer);
-      const glTFBufferView = {
-        buffer: bufferIndex,
-        // Write offset from the start of the binary body
-        byteOffset,
-        byteLength
-      };
-      this.byteLength += padToNBytes(byteLength, 4);
-      this.json.bufferViews = this.json.bufferViews || [];
-      this.json.bufferViews.push(glTFBufferView);
-      return this.json.bufferViews.length - 1;
+  }
+  function findPropertyTableByClass(propertyTables, schemaClassName) {
+    for (const propertyTable of propertyTables) {
+      if (propertyTable.class === schemaClassName) {
+        return propertyTable;
+      }
     }
-    /**
-     * Adds an accessor to a bufferView
-     * @param bufferViewIndex
-     * @param accessor
-     */
-    addAccessor(bufferViewIndex, accessor) {
-      const glTFAccessor = {
-        bufferView: bufferViewIndex,
-        // @ts-ignore
-        type: getAccessorTypeFromSize(accessor.size),
-        // @ts-ignore
-        componentType: accessor.componentType,
-        // @ts-ignore
-        count: accessor.count,
-        // @ts-ignore
-        max: accessor.max,
-        // @ts-ignore
-        min: accessor.min
-      };
-      this.json.accessors = this.json.accessors || [];
-      this.json.accessors.push(glTFAccessor);
-      return this.json.accessors.length - 1;
+    return null;
+  }
+  function processPrimitivePropertyTextures(scenegraph, propertyTextures, primitive, extension) {
+    if (!propertyTextures) {
+      return;
     }
-    /**
-     * Add a binary buffer. Builds glTF "JSON metadata" and saves buffer reference
-     * Buffer will be copied into BIN chunk during "pack"
-     * Currently encodes buffers as glTF accessors, but this could be optimized
-     * @param sourceBuffer
-     * @param accessor
-     */
-    addBinaryBuffer(sourceBuffer, accessor = { size: 3 }) {
-      const bufferViewIndex = this.addBufferView(sourceBuffer);
-      let minMax = { min: accessor.min, max: accessor.max };
-      if (!minMax.min || !minMax.max) {
-        minMax = this._getAccessorMinMax(sourceBuffer, accessor.size);
-      }
-      const accessorDefaults = {
-        // @ts-ignore
-        size: accessor.size,
-        componentType: getComponentTypeFromArray(sourceBuffer),
-        // @ts-ignore
-        count: Math.round(sourceBuffer.length / accessor.size),
-        min: minMax.min,
-        max: minMax.max
-      };
-      return this.addAccessor(bufferViewIndex, Object.assign(accessorDefaults, accessor));
+    const primitiveExtension = primitive.extensions?.[EXT_STRUCTURAL_METADATA_NAME];
+    const primitivePropertyTextureIndices = primitiveExtension?.propertyTextures;
+    if (!primitivePropertyTextureIndices) {
+      return;
     }
-    /**
-     * Adds a texture to the json part
-     * @todo: add more properties for texture initialization
-     * `sampler`, `name`, `extensions`, `extras`
-     * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#texture
-     */
-    addTexture(texture) {
-      const { imageIndex } = texture;
-      const glTFTexture = {
-        source: imageIndex
-      };
-      this.json.textures = this.json.textures || [];
-      this.json.textures.push(glTFTexture);
-      return this.json.textures.length - 1;
+    for (const primitivePropertyTextureIndex of primitivePropertyTextureIndices) {
+      const propertyTexture = propertyTextures[primitivePropertyTextureIndex];
+      processPrimitivePropertyTexture(scenegraph, propertyTexture, primitive, extension);
     }
-    /** Adds a material to the json part */
-    addMaterial(pbrMaterialInfo) {
-      this.json.materials = this.json.materials || [];
-      this.json.materials.push(pbrMaterialInfo);
-      return this.json.materials.length - 1;
+  }
+  function processPrimitivePropertyTexture(scenegraph, propertyTexture, primitive, extension) {
+    if (!propertyTexture.properties) {
+      return;
     }
-    /** Pack the binary chunk */
-    createBinaryChunk() {
-      const totalByteLength = this.byteLength;
-      const arrayBuffer = new ArrayBuffer(totalByteLength);
-      const targetArray = new Uint8Array(arrayBuffer);
-      let dstByteOffset = 0;
-      for (const sourceBuffer of this.sourceBuffers || []) {
-        dstByteOffset = copyToArray(sourceBuffer, targetArray, dstByteOffset);
-      }
-      if (this.json?.buffers?.[0]) {
-        this.json.buffers[0].byteLength = totalByteLength;
-      } else {
-        this.json.buffers = [{ byteLength: totalByteLength }];
-      }
-      this.gltf.binary = arrayBuffer;
-      this.sourceBuffers = [arrayBuffer];
-      this.gltf.buffers = [{ arrayBuffer, byteOffset: 0, byteLength: arrayBuffer.byteLength }];
+    if (!extension.dataAttributeNames) {
+      extension.dataAttributeNames = [];
     }
-    // PRIVATE
-    _removeStringFromArray(array, string) {
-      let found = true;
-      while (found) {
-        const index = array.indexOf(string);
-        if (index > -1) {
-          array.splice(index, 1);
-        } else {
-          found = false;
-        }
+    const className = propertyTexture.class;
+    for (const propertyName in propertyTexture.properties) {
+      const attributeName = `${className}_${propertyName}`;
+      const textureInfoTopLevel = propertyTexture.properties?.[propertyName];
+      if (!textureInfoTopLevel) {
+        continue;
       }
-    }
-    /**
-     * Add attributes to buffers and create `attributes` object which is part of `mesh`
-     */
-    _addAttributes(attributes = {}) {
-      const result = {};
-      for (const attributeKey in attributes) {
-        const attributeData = attributes[attributeKey];
-        const attrName = this._getGltfAttributeName(attributeKey);
-        const accessor = this.addBinaryBuffer(attributeData.value, attributeData);
-        result[attrName] = accessor;
+      if (!textureInfoTopLevel.data) {
+        textureInfoTopLevel.data = [];
       }
-      return result;
+      const featureTextureTable = textureInfoTopLevel.data;
+      const propertyData = getPrimitiveTextureData(scenegraph, textureInfoTopLevel, primitive);
+      if (propertyData === null) {
+        continue;
+      }
+      primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTextureTable, primitive);
+      textureInfoTopLevel.data = featureTextureTable;
+      extension.dataAttributeNames.push(attributeName);
     }
-    /**
-     * Add indices to buffers
-     */
-    _addIndices(indices) {
-      return this.addBinaryBuffer(indices, { size: 1 });
+  }
+  function processPropertyTable(scenegraph, schema, propertyTable) {
+    const schemaClass = schema.classes?.[propertyTable.class];
+    if (!schemaClass) {
+      throw new Error(`Incorrect data in the EXT_structural_metadata extension: no schema class with name ${propertyTable.class}`);
     }
-    /**
-     * Deduce gltf specific attribue name from input attribute name
-     */
-    _getGltfAttributeName(attributeName) {
-      switch (attributeName.toLowerCase()) {
-        case "position":
-        case "positions":
-        case "vertices":
-          return "POSITION";
-        case "normal":
-        case "normals":
-          return "NORMAL";
-        case "color":
-        case "colors":
-          return "COLOR_0";
-        case "texcoord":
-        case "texcoords":
-          return "TEXCOORD_0";
-        default:
-          return attributeName;
+    const numberOfElements = propertyTable.count;
+    for (const propertyName in schemaClass.properties) {
+      const classProperty = schemaClass.properties[propertyName];
+      const propertyTableProperty = propertyTable.properties?.[propertyName];
+      if (propertyTableProperty) {
+        const data = getPropertyDataFromBinarySource(scenegraph, schema, classProperty, numberOfElements, propertyTableProperty);
+        propertyTableProperty.data = data;
       }
     }
-    /**
-     * Calculate `min` and `max` arrays of accessor according to spec:
-     * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-accessor
-     */
-    _getAccessorMinMax(buffer, size) {
-      const result = { min: null, max: null };
-      if (buffer.length < size) {
-        return result;
+  }
+  function getPropertyDataFromBinarySource(scenegraph, schema, classProperty, numberOfElements, propertyTableProperty) {
+    let data = [];
+    const valuesBufferView = propertyTableProperty.values;
+    const valuesDataBytes = scenegraph.getTypedArrayForBufferView(valuesBufferView);
+    const arrayOffsets = getArrayOffsetsForProperty(scenegraph, classProperty, propertyTableProperty, numberOfElements);
+    const stringOffsets = getStringOffsetsForProperty(scenegraph, propertyTableProperty, numberOfElements);
+    switch (classProperty.type) {
+      case "SCALAR":
+      case "VEC2":
+      case "VEC3":
+      case "VEC4":
+      case "MAT2":
+      case "MAT3":
+      case "MAT4": {
+        data = getPropertyDataNumeric(classProperty, numberOfElements, valuesDataBytes, arrayOffsets);
+        break;
       }
-      result.min = [];
-      result.max = [];
-      const initValues = buffer.subarray(0, size);
-      for (const value of initValues) {
-        result.min.push(value);
-        result.max.push(value);
+      case "BOOLEAN": {
+        throw new Error(`Not implemented - classProperty.type=${classProperty.type}`);
       }
-      for (let index = size; index < buffer.length; index += size) {
-        for (let componentIndex = 0; componentIndex < size; componentIndex++) {
-          result.min[0 + componentIndex] = Math.min(
-            // @ts-ignore
-            result.min[0 + componentIndex],
-            buffer[index + componentIndex]
-          );
-          result.max[0 + componentIndex] = Math.max(
-            // @ts-ignore
-            result.max[0 + componentIndex],
-            buffer[index + componentIndex]
-          );
-        }
+      case "STRING": {
+        data = getPropertyDataString(numberOfElements, valuesDataBytes, arrayOffsets, stringOffsets);
+        break;
       }
-      return result;
+      case "ENUM": {
+        data = getPropertyDataENUM(schema, classProperty, numberOfElements, valuesDataBytes, arrayOffsets);
+        break;
+      }
+      default:
+        throw new Error(`Unknown classProperty type ${classProperty.type}`);
     }
-  };
-
-  // ../../node_modules/@loaders.gl/gltf/dist/lib/extensions/utils/3d-tiles-utils.js
-  function emod(n) {
-    return (n % 1 + 1) % 1;
-  }
-  var ATTRIBUTE_TYPE_TO_COMPONENTS2 = {
-    SCALAR: 1,
-    VEC2: 2,
-    VEC3: 3,
-    VEC4: 4,
-    MAT2: 4,
-    MAT3: 9,
-    MAT4: 16,
-    BOOLEAN: 1,
-    STRING: 1,
-    ENUM: 1
-  };
-  var ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY2 = {
-    INT8: Int8Array,
-    UINT8: Uint8Array,
-    INT16: Int16Array,
-    UINT16: Uint16Array,
-    INT32: Int32Array,
-    UINT32: Uint32Array,
-    INT64: BigInt64Array,
-    UINT64: BigUint64Array,
-    FLOAT32: Float32Array,
-    FLOAT64: Float64Array
-  };
-  var ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2 = {
-    INT8: 1,
-    UINT8: 1,
-    INT16: 2,
-    UINT16: 2,
-    INT32: 4,
-    UINT32: 4,
-    INT64: 8,
-    UINT64: 8,
-    FLOAT32: 4,
-    FLOAT64: 8
-  };
-  function getArrayElementByteSize(attributeType, componentType) {
-    return ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2[componentType] * ATTRIBUTE_TYPE_TO_COMPONENTS2[attributeType];
+    return data;
   }
-  function getOffsetsForProperty(scenegraph, bufferViewIndex, offsetType, numberOfElements) {
-    if (offsetType !== "UINT8" && offsetType !== "UINT16" && offsetType !== "UINT32" && offsetType !== "UINT64") {
-      return null;
-    }
-    const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(bufferViewIndex);
-    const arrayOffsets = convertRawBufferToMetadataArray(
-      arrayOffsetsBytes,
-      "SCALAR",
-      // offsets consist of ONE component
-      offsetType,
-      numberOfElements + 1
-      // The number of offsets is equal to the property table `count` plus one.
-    );
-    if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {
-      return null;
+  function getArrayOffsetsForProperty(scenegraph, classProperty, propertyTableProperty, numberOfElements) {
+    if (classProperty.array && // `count` is a number of array elements. May only be defined when `array` is true.
+    // If `count` is NOT defined, it's a VARIABLE-length array
+    typeof classProperty.count === "undefined" && // `arrayOffsets` is an index of the buffer view containing offsets for variable-length arrays.
+    typeof propertyTableProperty.arrayOffsets !== "undefined") {
+      return getOffsetsForProperty(scenegraph, propertyTableProperty.arrayOffsets, propertyTableProperty.arrayOffsetType || "UINT32", numberOfElements);
     }
-    return arrayOffsets;
+    return null;
   }
-  function convertRawBufferToMetadataArray(data, attributeType, componentType, elementCount = 1) {
-    const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS2[attributeType];
-    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY2[componentType];
-    const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2[componentType];
-    const length8 = elementCount * numberOfComponents;
-    const byteLength = length8 * size;
-    let buffer = data.buffer;
-    let offset = data.byteOffset;
-    if (offset % size !== 0) {
-      const bufferArray = new Uint8Array(buffer);
-      buffer = bufferArray.slice(offset, offset + byteLength).buffer;
-      offset = 0;
+  function getStringOffsetsForProperty(scenegraph, propertyTableProperty, numberOfElements) {
+    if (typeof propertyTableProperty.stringOffsets !== "undefined") {
+      return getOffsetsForProperty(scenegraph, propertyTableProperty.stringOffsets, propertyTableProperty.stringOffsetType || "UINT32", numberOfElements);
     }
-    return new ArrayType(ensureArrayBuffer(buffer), offset, length8);
+    return null;
   }
-  function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
-    const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;
-    const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
-    const textureCoordinates = scenegraph.getTypedArrayForAccessor(texCoordAccessorIndex);
-    const json = scenegraph.gltf.json;
-    const textureIndex = textureInfo.index;
-    const imageIndex = json.textures?.[textureIndex]?.source;
-    if (typeof imageIndex !== "undefined") {
-      const mimeType = json.images?.[imageIndex]?.mimeType;
-      const parsedImage = scenegraph.gltf.images?.[imageIndex];
-      if (parsedImage && typeof parsedImage.width !== "undefined") {
-        const textureData = [];
-        for (let index = 0; index < textureCoordinates.length; index += 2) {
-          const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, textureInfo.channels);
-          textureData.push(value);
-        }
-        return textureData;
+  function getPropertyDataNumeric(classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
+    const isArray2 = classProperty.array;
+    const arrayCount = classProperty.count;
+    const elementSize = getArrayElementByteSize(classProperty.type, classProperty.componentType);
+    const elementCount = valuesDataBytes.byteLength / elementSize;
+    let valuesData;
+    if (classProperty.componentType) {
+      valuesData = convertRawBufferToMetadataArray(
+        valuesDataBytes,
+        classProperty.type,
+        // The datatype of the element's components. Only applicable to `SCALAR`, `VECN`, and `MATN` types.
+        classProperty.componentType,
+        elementCount
+      );
+    } else {
+      valuesData = valuesDataBytes;
+    }
+    if (isArray2) {
+      if (arrayOffsets) {
+        return parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
+      }
+      if (arrayCount) {
+        return parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
       }
+      return [];
     }
-    return [];
+    return valuesData;
   }
-  function primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTable, primitive) {
-    if (!propertyData?.length) {
-      return;
+  function getPropertyDataENUM(schema, classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
+    const enumType = classProperty.enumType;
+    if (!enumType) {
+      throw new Error("Incorrect data in the EXT_structural_metadata extension: classProperty.enumType is not set for type ENUM");
+    }
+    const enumEntry = schema.enums?.[enumType];
+    if (!enumEntry) {
+      throw new Error(`Incorrect data in the EXT_structural_metadata extension: schema.enums does't contain ${enumType}`);
+    }
+    const enumValueType = enumEntry.valueType || "UINT16";
+    const elementSize = getArrayElementByteSize(classProperty.type, enumValueType);
+    const elementCount = valuesDataBytes.byteLength / elementSize;
+    let valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, enumValueType, elementCount);
+    if (!valuesData) {
+      valuesData = valuesDataBytes;
     }
-    const featureIndices = [];
-    for (const texelData of propertyData) {
-      let index = featureTable.findIndex((item) => item === texelData);
-      if (index === -1) {
-        index = featureTable.push(texelData) - 1;
+    if (classProperty.array) {
+      if (arrayOffsets) {
+        return parseVariableLengthArrayENUM({
+          valuesData,
+          numberOfElements,
+          arrayOffsets,
+          valuesDataBytesLength: valuesDataBytes.length,
+          elementSize,
+          enumEntry
+        });
       }
-      featureIndices.push(index);
-    }
-    const typedArray = new Uint32Array(featureIndices);
-    const bufferIndex = scenegraph.gltf.buffers.push({
-      arrayBuffer: typedArray.buffer,
-      byteOffset: typedArray.byteOffset,
-      byteLength: typedArray.byteLength
-    }) - 1;
-    const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
-    const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
-      size: 1,
-      componentType: getComponentTypeFromArray(typedArray),
-      count: typedArray.length
-    });
-    primitive.attributes[attributeName] = accessorIndex;
-  }
-  function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels = [0]) {
-    const CHANNELS_MAP = {
-      r: { offset: 0, shift: 0 },
-      g: { offset: 1, shift: 8 },
-      b: { offset: 2, shift: 16 },
-      a: { offset: 3, shift: 24 }
-    };
-    const u2 = textureCoordinates[index];
-    const v2 = textureCoordinates[index + 1];
-    let components = 1;
-    if (mimeType && (mimeType.indexOf("image/jpeg") !== -1 || mimeType.indexOf("image/png") !== -1))
-      components = 4;
-    const offset = coordinatesToOffset(u2, v2, parsedImage, components);
-    let value = 0;
-    for (const c2 of channels) {
-      const map2 = typeof c2 === "number" ? Object.values(CHANNELS_MAP)[c2] : CHANNELS_MAP[c2];
-      const imageOffset = offset + map2.offset;
-      const imageData = getImageData(parsedImage);
-      if (imageData.data.length <= imageOffset) {
-        throw new Error(`${imageData.data.length} <= ${imageOffset}`);
+      const arrayCount = classProperty.count;
+      if (arrayCount) {
+        return parseFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry);
       }
-      const imageValue = imageData.data[imageOffset];
-      value |= imageValue << map2.shift;
+      return [];
     }
-    return value;
-  }
-  function coordinatesToOffset(u2, v2, parsedImage, componentsCount = 1) {
-    const w2 = parsedImage.width;
-    const iX = emod(u2) * (w2 - 1);
-    const indX = Math.round(iX);
-    const h = parsedImage.height;
-    const iY = emod(v2) * (h - 1);
-    const indY = Math.round(iY);
-    const components = parsedImage.components ? parsedImage.components : componentsCount;
-    const offset = (indY * w2 + indX) * components;
-    return offset;
+    return getEnumsArray(valuesData, 0, numberOfElements, enumEntry);
   }
-  function parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, valueSize) {
+  function parseVariableLengthArrayENUM(params) {
+    const { valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, elementSize, enumEntry } = params;
     const attributeValueArray = [];
     for (let index = 0; index < numberOfElements; index++) {
       const arrayOffset = arrayOffsets[index];
@@ -26827,273 +26643,275 @@ void main(void) {
       if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
         break;
       }
-      const typedArrayOffset = arrayOffset / valueSize;
-      const elementCount = arrayByteSize / valueSize;
-      attributeValueArray.push(valuesData.slice(typedArrayOffset, typedArrayOffset + elementCount));
+      const typedArrayOffset = arrayOffset / elementSize;
+      const elementCount = arrayByteSize / elementSize;
+      const array = getEnumsArray(valuesData, typedArrayOffset, elementCount, enumEntry);
+      attributeValueArray.push(array);
     }
     return attributeValueArray;
   }
-  function parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount) {
+  function parseFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry) {
     const attributeValueArray = [];
     for (let index = 0; index < numberOfElements; index++) {
-      const elementOffset = index * arrayCount;
-      attributeValueArray.push(valuesData.slice(elementOffset, elementOffset + arrayCount));
+      const elementOffset = arrayCount * index;
+      const array = getEnumsArray(valuesData, elementOffset, arrayCount, enumEntry);
+      attributeValueArray.push(array);
     }
     return attributeValueArray;
   }
-  function getPropertyDataString(numberOfElements, valuesDataBytes, arrayOffsets, stringOffsets) {
-    if (arrayOffsets) {
-      throw new Error("Not implemented - arrayOffsets for strings is specified");
-    }
-    if (stringOffsets) {
-      const stringsArray = [];
-      const textDecoder = new TextDecoder("utf8");
-      let stringOffset = 0;
-      for (let index = 0; index < numberOfElements; index++) {
-        const stringByteSize = stringOffsets[index + 1] - stringOffsets[index];
-        if (stringByteSize + stringOffset <= valuesDataBytes.length) {
-          const stringData = valuesDataBytes.subarray(stringOffset, stringByteSize + stringOffset);
-          const stringAttribute = textDecoder.decode(stringData);
-          stringsArray.push(stringAttribute);
-          stringOffset += stringByteSize;
+  function getEnumsArray(valuesData, offset, count, enumEntry) {
+    const array = [];
+    for (let i = 0; i < count; i++) {
+      if (valuesData instanceof BigInt64Array || valuesData instanceof BigUint64Array) {
+        array.push("");
+      } else {
+        const value = valuesData[offset + i];
+        const enumObject = getEnumByValue(enumEntry, value);
+        if (enumObject) {
+          array.push(enumObject.name);
+        } else {
+          array.push("");
         }
       }
-      return stringsArray;
     }
-    return [];
-  }
-
-  // ../../node_modules/@loaders.gl/gltf/dist/lib/extensions/EXT_mesh_features.js
-  var EXT_MESH_FEATURES_NAME = "EXT_mesh_features";
-  var name = EXT_MESH_FEATURES_NAME;
-  async function decode(gltfData, options) {
-    const scenegraph = new GLTFScenegraph(gltfData);
-    decodeExtMeshFeatures(scenegraph, options);
+    return array;
   }
-  function encode(gltfData, options) {
-    const scenegraph = new GLTFScenegraph(gltfData);
-    encodeExtMeshFeatures(scenegraph, options);
-    scenegraph.createBinaryChunk();
-    return scenegraph.gltf;
+  function getEnumByValue(enumEntry, value) {
+    for (const enumValue of enumEntry.values) {
+      if (enumValue.value === value) {
+        return enumValue;
+      }
+    }
+    return null;
   }
-  function decodeExtMeshFeatures(scenegraph, options) {
-    const json = scenegraph.gltf.json;
-    if (!json.meshes) {
+  var SCHEMA_CLASS_ID_DEFAULT = "schemaClassId";
+  function encodeExtStructuralMetadata(scenegraph, options) {
+    const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
+    if (!extension) {
       return;
     }
-    for (const mesh of json.meshes) {
-      for (const primitive of mesh.primitives) {
-        processMeshPrimitiveFeatures(scenegraph, primitive, options);
+    if (extension.propertyTables) {
+      for (const table of extension.propertyTables) {
+        const classId = table.class;
+        const schemaClass = extension.schema?.classes?.[classId];
+        if (table.properties && schemaClass) {
+          encodeProperties(table, schemaClass, scenegraph);
+        }
       }
     }
   }
-  function processMeshPrimitiveFeatures(scenegraph, primitive, options) {
-    if (!options?.gltf?.loadBuffers) {
-      return;
+  function encodeProperties(table, schemaClass, scenegraph) {
+    for (const propertyName in table.properties) {
+      const data = table.properties[propertyName].data;
+      if (data) {
+        const classProperty = schemaClass.properties[propertyName];
+        if (classProperty) {
+          const tableProperty = createPropertyTableProperty(data, classProperty, scenegraph);
+          table.properties[propertyName] = tableProperty;
+        }
+      }
     }
-    const extension = primitive.extensions?.[EXT_MESH_FEATURES_NAME];
-    const featureIds = extension?.featureIds;
-    if (!featureIds) {
-      return;
+  }
+  function createExtStructuralMetadata(scenegraph, propertyAttributes, classId = SCHEMA_CLASS_ID_DEFAULT) {
+    let extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
+    if (!extension) {
+      extension = scenegraph.addExtension(EXT_STRUCTURAL_METADATA_NAME);
     }
-    for (const featureId of featureIds) {
-      let featureIdData;
-      if (typeof featureId.attribute !== "undefined") {
-        const accessorKey = `_FEATURE_ID_${featureId.attribute}`;
-        const accessorIndex = primitive.attributes[accessorKey];
-        featureIdData = scenegraph.getTypedArrayForAccessor(accessorIndex);
-      } else if (typeof featureId.texture !== "undefined" && options?.gltf?.loadImages) {
-        featureIdData = getPrimitiveTextureData(scenegraph, featureId.texture, primitive);
-      } else {
-        featureIdData = [];
-      }
-      featureId.data = featureIdData;
+    extension.schema = createSchema(propertyAttributes, classId, extension.schema);
+    const table = createPropertyTable(propertyAttributes, classId, extension.schema);
+    if (!extension.propertyTables) {
+      extension.propertyTables = [];
     }
+    return extension.propertyTables.push(table) - 1;
   }
-  function encodeExtMeshFeatures(scenegraph, options) {
-    const meshes = scenegraph.gltf.json.meshes;
-    if (!meshes) {
-      return;
+  function createSchema(propertyAttributes, classId, schemaToUpdate) {
+    const schema = schemaToUpdate ?? {
+      id: "schema_id"
+    };
+    const schemaClass = {
+      properties: {}
+    };
+    for (const attribute of propertyAttributes) {
+      const classProperty = {
+        type: attribute.elementType,
+        componentType: attribute.componentType
+      };
+      schemaClass.properties[attribute.name] = classProperty;
     }
-    for (const mesh of meshes) {
-      for (const primitive of mesh.primitives) {
-        encodeExtMeshFeaturesForPrimitive(scenegraph, primitive);
+    schema.classes = {};
+    schema.classes[classId] = schemaClass;
+    return schema;
+  }
+  function createPropertyTable(propertyAttributes, classId, schema) {
+    const table = {
+      class: classId,
+      count: 0
+    };
+    let count = 0;
+    const schemaClass = schema.classes?.[classId];
+    for (const attribute of propertyAttributes) {
+      if (count === 0) {
+        count = attribute.values.length;
+      }
+      if (count !== attribute.values.length && attribute.values.length) {
+        throw new Error("Illegal values in attributes");
+      }
+      const classProperty = schemaClass?.properties[attribute.name];
+      if (classProperty) {
+        if (!table.properties) {
+          table.properties = {};
+        }
+        table.properties[attribute.name] = { values: 0, data: attribute.values };
       }
     }
+    table.count = count;
+    return table;
+  }
+  function createPropertyTableProperty(values, classProperty, scenegraph) {
+    const prop = { values: 0 };
+    if (classProperty.type === "STRING") {
+      const { stringData, stringOffsets } = createPropertyDataString(values);
+      prop.stringOffsets = createBufferView(stringOffsets, scenegraph);
+      prop.values = createBufferView(stringData, scenegraph);
+    } else if (classProperty.type === "SCALAR" && classProperty.componentType) {
+      const data = createPropertyDataScalar(values, classProperty.componentType);
+      prop.values = createBufferView(data, scenegraph);
+    }
+    return prop;
   }
-  function createExtMeshFeatures(scenegraph, primitive, featureIdArray, propertyTableIndex) {
-    if (!primitive.extensions) {
-      primitive.extensions = {};
+  var COMPONENT_TYPE_TO_ARRAY_CONSTRUCTOR = {
+    INT8: Int8Array,
+    UINT8: Uint8Array,
+    INT16: Int16Array,
+    UINT16: Uint16Array,
+    INT32: Int32Array,
+    UINT32: Uint32Array,
+    INT64: Int32Array,
+    UINT64: Uint32Array,
+    FLOAT32: Float32Array,
+    FLOAT64: Float64Array
+  };
+  function createPropertyDataScalar(array, componentType) {
+    const numberArray = [];
+    for (const value of array) {
+      numberArray.push(Number(value));
     }
-    let extension = primitive.extensions[EXT_MESH_FEATURES_NAME];
-    if (!extension) {
-      extension = { featureIds: [] };
-      primitive.extensions[EXT_MESH_FEATURES_NAME] = extension;
+    const Construct = COMPONENT_TYPE_TO_ARRAY_CONSTRUCTOR[componentType];
+    if (!Construct) {
+      throw new Error("Illegal component type");
     }
-    const { featureIds } = extension;
-    const featureId = {
-      featureCount: featureIdArray.length,
-      propertyTable: propertyTableIndex,
-      data: featureIdArray
-    };
-    featureIds.push(featureId);
-    scenegraph.addObjectExtension(primitive, EXT_MESH_FEATURES_NAME, extension);
+    return new Construct(numberArray);
   }
-  function encodeExtMeshFeaturesForPrimitive(scenegraph, primitive) {
-    const extension = primitive.extensions?.[EXT_MESH_FEATURES_NAME];
-    if (!extension) {
-      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 featureIds = extension.featureIds;
-    featureIds.forEach((featureId, elementIndex) => {
-      if (featureId.data) {
-        const { accessorKey, index } = createAccessorKey(primitive.attributes);
-        const typedArray = new Uint32Array(featureId.data);
-        featureIds[elementIndex] = {
-          featureCount: typedArray.length,
-          propertyTable: featureId.propertyTable,
-          attribute: index
-        };
-        scenegraph.gltf.buffers.push({
-          arrayBuffer: typedArray.buffer,
-          byteOffset: typedArray.byteOffset,
-          byteLength: typedArray.byteLength
-        });
-        const bufferViewIndex = scenegraph.addBufferView(typedArray);
-        const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
-          size: 1,
-          componentType: getComponentTypeFromArray(typedArray),
-          count: typedArray.length
-        });
-        primitive.attributes[accessorKey] = accessorIndex;
-      }
-    });
-  }
-  function createAccessorKey(attributes) {
-    const prefix = "_FEATURE_ID_";
-    const attrs = Object.keys(attributes).filter((item) => item.indexOf(prefix) === 0);
-    let max4 = -1;
-    for (const a2 of attrs) {
-      const n = Number(a2.substring(prefix.length));
-      if (n > max4) {
-        max4 = n;
-      }
+    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;
     }
-    max4++;
-    const accessorKey = `${prefix}${max4}`;
-    return { accessorKey, index: max4 };
+    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/EXT_structural_metadata.js
-  var EXT_structural_metadata_exports = {};
-  __export(EXT_structural_metadata_exports, {
-    createExtStructuralMetadata: () => createExtStructuralMetadata,
-    decode: () => decode2,
-    encode: () => encode2,
-    name: () => name2
+  // ../../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_STRUCTURAL_METADATA_NAME = "EXT_structural_metadata";
-  var name2 = EXT_STRUCTURAL_METADATA_NAME;
-  async function decode2(gltfData, options) {
-    const scenegraph = new GLTFScenegraph(gltfData);
-    decodeExtStructuralMetadata(scenegraph, options);
-  }
-  function encode2(gltfData, options) {
+  var EXT_FEATURE_METADATA_NAME = "EXT_feature_metadata";
+  var name3 = EXT_FEATURE_METADATA_NAME;
+  async function decode3(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
-    encodeExtStructuralMetadata(scenegraph, options);
-    scenegraph.createBinaryChunk();
-    return scenegraph.gltf;
+    decodeExtFeatureMetadata(scenegraph, options);
   }
-  function decodeExtStructuralMetadata(scenegraph, options) {
+  function decodeExtFeatureMetadata(scenegraph, options) {
     if (!options.gltf?.loadBuffers) {
       return;
     }
-    const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
+    const extension = scenegraph.getExtension(EXT_FEATURE_METADATA_NAME);
     if (!extension) {
       return;
     }
     if (options.gltf?.loadImages) {
-      decodePropertyTextures(scenegraph, extension);
+      decodePropertyTextures2(scenegraph, extension);
     }
-    decodePropertyTables(scenegraph, extension);
+    decodePropertyTables2(scenegraph, extension);
   }
-  function decodePropertyTextures(scenegraph, extension) {
-    const propertyTextures = extension.propertyTextures;
-    const json = scenegraph.gltf.json;
-    if (propertyTextures && json.meshes) {
-      for (const mesh of json.meshes) {
-        for (const primitive of mesh.primitives) {
-          processPrimitivePropertyTextures(scenegraph, propertyTextures, primitive, 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 decodePropertyTables(scenegraph, extension) {
+  function decodePropertyTables2(scenegraph, extension) {
     const schema = extension.schema;
     if (!schema) {
       return;
     }
     const schemaClasses = schema.classes;
-    const propertyTables = extension.propertyTables;
+    const propertyTables = extension.featureTables;
     if (schemaClasses && propertyTables) {
       for (const schemaName in schemaClasses) {
-        const propertyTable = findPropertyTableByClass(propertyTables, schemaName);
+        const propertyTable = findPropertyTableByClass2(propertyTables, schemaName);
         if (propertyTable) {
-          processPropertyTable(scenegraph, schema, propertyTable);
+          processPropertyTable2(scenegraph, schema, propertyTable);
         }
       }
     }
   }
-  function findPropertyTableByClass(propertyTables, schemaClassName) {
-    for (const propertyTable of propertyTables) {
+  function findPropertyTableByClass2(propertyTables, schemaClassName) {
+    for (const propertyTableName in propertyTables) {
+      const propertyTable = propertyTables[propertyTableName];
       if (propertyTable.class === schemaClassName) {
         return propertyTable;
       }
     }
     return null;
   }
-  function processPrimitivePropertyTextures(scenegraph, propertyTextures, primitive, extension) {
-    if (!propertyTextures) {
-      return;
-    }
-    const primitiveExtension = primitive.extensions?.[EXT_STRUCTURAL_METADATA_NAME];
-    const primitivePropertyTextureIndices = primitiveExtension?.propertyTextures;
-    if (!primitivePropertyTextureIndices) {
-      return;
-    }
-    for (const primitivePropertyTextureIndex of primitivePropertyTextureIndices) {
-      const propertyTexture = propertyTextures[primitivePropertyTextureIndex];
-      processPrimitivePropertyTexture(scenegraph, propertyTexture, primitive, extension);
+  function findFeatureTextureByClass(featureTextures, schemaClassName) {
+    for (const featureTexturesName in featureTextures) {
+      const featureTable = featureTextures[featureTexturesName];
+      if (featureTable.class === schemaClassName) {
+        return featureTable;
+      }
     }
+    return null;
   }
-  function processPrimitivePropertyTexture(scenegraph, propertyTexture, primitive, extension) {
-    if (!propertyTexture.properties) {
+  function processPropertyTable2(scenegraph, schema, propertyTable) {
+    if (!propertyTable.class) {
       return;
     }
-    if (!extension.dataAttributeNames) {
-      extension.dataAttributeNames = [];
-    }
-    const className = propertyTexture.class;
-    for (const propertyName in propertyTexture.properties) {
-      const attributeName = `${className}_${propertyName}`;
-      const textureInfoTopLevel = propertyTexture.properties?.[propertyName];
-      if (!textureInfoTopLevel) {
-        continue;
-      }
-      if (!textureInfoTopLevel.data) {
-        textureInfoTopLevel.data = [];
-      }
-      const featureTextureTable = textureInfoTopLevel.data;
-      const propertyData = getPrimitiveTextureData(scenegraph, textureInfoTopLevel, primitive);
-      if (propertyData === null) {
-        continue;
-      }
-      primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTextureTable, primitive);
-      textureInfoTopLevel.data = featureTextureTable;
-      extension.dataAttributeNames.push(attributeName);
-    }
-  }
-  function processPropertyTable(scenegraph, schema, propertyTable) {
     const schemaClass = schema.classes?.[propertyTable.class];
     if (!schemaClass) {
       throw new Error(`Incorrect data in the EXT_structural_metadata extension: no schema class with name ${propertyTable.class}`);
@@ -27103,76 +26921,83 @@ void main(void) {
       const classProperty = schemaClass.properties[propertyName];
       const propertyTableProperty = propertyTable.properties?.[propertyName];
       if (propertyTableProperty) {
-        const data = getPropertyDataFromBinarySource(scenegraph, schema, classProperty, numberOfElements, propertyTableProperty);
+        const data = getPropertyDataFromBinarySource2(scenegraph, schema, classProperty, numberOfElements, propertyTableProperty);
         propertyTableProperty.data = data;
       }
     }
   }
-  function getPropertyDataFromBinarySource(scenegraph, schema, classProperty, numberOfElements, propertyTableProperty) {
-    let data = [];
-    const valuesBufferView = propertyTableProperty.values;
-    const valuesDataBytes = scenegraph.getTypedArrayForBufferView(valuesBufferView);
-    const arrayOffsets = getArrayOffsetsForProperty(scenegraph, classProperty, propertyTableProperty, numberOfElements);
-    const stringOffsets = getStringOffsetsForProperty(scenegraph, propertyTableProperty, numberOfElements);
-    switch (classProperty.type) {
-      case "SCALAR":
-      case "VEC2":
-      case "VEC3":
-      case "VEC4":
-      case "MAT2":
-      case "MAT3":
-      case "MAT4": {
-        data = getPropertyDataNumeric(classProperty, numberOfElements, valuesDataBytes, arrayOffsets);
-        break;
-      }
-      case "BOOLEAN": {
-        throw new Error(`Not implemented - classProperty.type=${classProperty.type}`);
-      }
-      case "STRING": {
-        data = getPropertyDataString(numberOfElements, valuesDataBytes, arrayOffsets, stringOffsets);
-        break;
-      }
-      case "ENUM": {
-        data = getPropertyDataENUM(schema, classProperty, numberOfElements, valuesDataBytes, arrayOffsets);
-        break;
+  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;
       }
-      default:
-        throw new Error(`Unknown classProperty type ${classProperty.type}`);
+    }
+  }
+  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 getArrayOffsetsForProperty(scenegraph, classProperty, propertyTableProperty, numberOfElements) {
-    if (classProperty.array && // `count` is a number of array elements. May only be defined when `array` is true.
-    // If `count` is NOT defined, it's a VARIABLE-length array
-    typeof classProperty.count === "undefined" && // `arrayOffsets` is an index of the buffer view containing offsets for variable-length arrays.
-    typeof propertyTableProperty.arrayOffsets !== "undefined") {
-      return getOffsetsForProperty(scenegraph, propertyTableProperty.arrayOffsets, propertyTableProperty.arrayOffsetType || "UINT32", numberOfElements);
+  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 getStringOffsetsForProperty(scenegraph, propertyTableProperty, numberOfElements) {
-    if (typeof propertyTableProperty.stringOffsets !== "undefined") {
-      return getOffsetsForProperty(scenegraph, propertyTableProperty.stringOffsets, propertyTableProperty.stringOffsetType || "UINT32", numberOfElements);
+  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 getPropertyDataNumeric(classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
-    const isArray2 = classProperty.array;
-    const arrayCount = classProperty.count;
-    const elementSize = getArrayElementByteSize(classProperty.type, classProperty.componentType);
+  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;
-    let valuesData;
-    if (classProperty.componentType) {
-      valuesData = convertRawBufferToMetadataArray(
-        valuesDataBytes,
-        classProperty.type,
-        // The datatype of the element's components. Only applicable to `SCALAR`, `VECN`, and `MATN` types.
-        classProperty.componentType,
-        elementCount
-      );
-    } else {
-      valuesData = valuesDataBytes;
-    }
+    const valuesData = convertRawBufferToMetadataArray(valuesDataBytes, attributeType, componentType, elementCount);
     if (isArray2) {
       if (arrayOffsets) {
         return parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
@@ -27184,443 +27009,618 @@ void main(void) {
     }
     return valuesData;
   }
-  function getPropertyDataENUM(schema, classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
-    const enumType = classProperty.enumType;
-    if (!enumType) {
-      throw new Error("Incorrect data in the EXT_structural_metadata extension: classProperty.enumType is not set for type ENUM");
-    }
-    const enumEntry = schema.enums?.[enumType];
-    if (!enumEntry) {
-      throw new Error(`Incorrect data in the EXT_structural_metadata extension: schema.enums does't contain ${enumType}`);
-    }
-    const enumValueType = enumEntry.valueType || "UINT16";
-    const elementSize = getArrayElementByteSize(classProperty.type, enumValueType);
-    const elementCount = valuesDataBytes.byteLength / elementSize;
-    let valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, enumValueType, elementCount);
-    if (!valuesData) {
-      valuesData = valuesDataBytes;
-    }
-    if (classProperty.array) {
-      if (arrayOffsets) {
-        return parseVariableLengthArrayENUM({
-          valuesData,
-          numberOfElements,
-          arrayOffsets,
-          valuesDataBytesLength: valuesDataBytes.length,
-          elementSize,
-          enumEntry
-        });
-      }
-      const arrayCount = classProperty.count;
-      if (arrayCount) {
-        return parseFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry);
-      }
+  function getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName) {
+    const json = scenegraph.gltf.json;
+    if (!json.meshes) {
       return [];
     }
-    return getEnumsArray(valuesData, 0, numberOfElements, enumEntry);
-  }
-  function parseVariableLengthArrayENUM(params) {
-    const { valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, elementSize, enumEntry } = params;
-    const attributeValueArray = [];
-    for (let index = 0; index < numberOfElements; index++) {
-      const arrayOffset = arrayOffsets[index];
-      const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
-      if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
-        break;
-      }
-      const typedArrayOffset = arrayOffset / elementSize;
-      const elementCount = arrayByteSize / elementSize;
-      const array = getEnumsArray(valuesData, typedArrayOffset, elementCount, enumEntry);
-      attributeValueArray.push(array);
-    }
-    return attributeValueArray;
-  }
-  function parseFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry) {
-    const attributeValueArray = [];
-    for (let index = 0; index < numberOfElements; index++) {
-      const elementOffset = arrayCount * index;
-      const array = getEnumsArray(valuesData, elementOffset, arrayCount, enumEntry);
-      attributeValueArray.push(array);
-    }
-    return attributeValueArray;
-  }
-  function getEnumsArray(valuesData, offset, count, enumEntry) {
-    const array = [];
-    for (let i = 0; i < count; i++) {
-      if (valuesData instanceof BigInt64Array || valuesData instanceof BigUint64Array) {
-        array.push("");
-      } else {
-        const value = valuesData[offset + i];
-        const enumObject = getEnumByValue(enumEntry, value);
-        if (enumObject) {
-          array.push(enumObject.name);
-        } else {
-          array.push("");
-        }
-      }
-    }
-    return array;
-  }
-  function getEnumByValue(enumEntry, value) {
-    for (const enumValue of enumEntry.values) {
-      if (enumValue.value === value) {
-        return enumValue;
+    const featureTextureTable = [];
+    for (const mesh of json.meshes) {
+      for (const primitive of mesh.primitives) {
+        processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive);
       }
     }
-    return null;
+    return featureTextureTable;
   }
-  var SCHEMA_CLASS_ID_DEFAULT = "schemaClassId";
-  function encodeExtStructuralMetadata(scenegraph, options) {
-    const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
-    if (!extension) {
+  function processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive) {
+    const textureInfoTopLevel = {
+      channels: featureTextureProperty.channels,
+      ...featureTextureProperty.texture
+    };
+    const propertyData = getPrimitiveTextureData(scenegraph, textureInfoTopLevel, primitive);
+    if (!propertyData) {
       return;
     }
-    if (extension.propertyTables) {
-      for (const table of extension.propertyTables) {
-        const classId = table.class;
-        const schemaClass = extension.schema?.classes?.[classId];
-        if (table.properties && schemaClass) {
-          encodeProperties(table, schemaClass, scenegraph);
-        }
-      }
-    }
+    primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTextureTable, primitive);
   }
-  function encodeProperties(table, schemaClass, scenegraph) {
-    for (const propertyName in table.properties) {
-      const data = table.properties[propertyName].data;
-      if (data) {
-        const classProperty = schemaClass.properties[propertyName];
-        if (classProperty) {
-          const tableProperty = createPropertyTableProperty(data, classProperty, scenegraph);
-          table.properties[propertyName] = tableProperty;
-        }
-      }
+
+  // ../../node_modules/@loaders.gl/gltf/dist/lib/utils/version.js
+  var VERSION10 = true ? "4.4.3" : "latest";
+
+  // ../../node_modules/@loaders.gl/gltf/node_modules/@loaders.gl/textures/dist/lib/utils/version.js
+  var VERSION11 = true ? "4.4.3" : "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;
   }
-  function createExtStructuralMetadata(scenegraph, propertyAttributes, classId = SCHEMA_CLASS_ID_DEFAULT) {
-    let extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
-    if (!extension) {
-      extension = scenegraph.addExtension(EXT_STRUCTURAL_METADATA_NAME);
-    }
-    extension.schema = createSchema(propertyAttributes, classId, extension.schema);
-    const table = createPropertyTable(propertyAttributes, classId, extension.schema);
-    if (!extension.propertyTables) {
-      extension.propertyTables = [];
-    }
-    return extension.propertyTables.push(table) - 1;
+  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);
   }
-  function createSchema(propertyAttributes, classId, schemaToUpdate) {
-    const schema = schemaToUpdate ?? {
-      id: "schema_id"
-    };
-    const schemaClass = {
-      properties: {}
-    };
-    for (const attribute of propertyAttributes) {
-      const classProperty = {
-        type: attribute.elementType,
-        componentType: attribute.componentType
-      };
-      schemaClass.properties[attribute.name] = classProperty;
+  function initializeBasisTranscoderModule(BasisModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
     }
-    schema.classes = {};
-    schema.classes[classId] = schemaClass;
-    return schema;
+    return new Promise((resolve2) => {
+      BasisModule(options).then((module) => {
+        const { BasisFile, initializeBasis } = module;
+        initializeBasis();
+        resolve2({ BasisFile });
+      });
+    });
   }
-  function createPropertyTable(propertyAttributes, classId, schema) {
-    const table = {
-      class: classId,
-      count: 0
-    };
-    let count = 0;
-    const schemaClass = schema.classes?.[classId];
-    for (const attribute of propertyAttributes) {
-      if (count === 0) {
-        count = attribute.values.length;
-      }
-      if (count !== attribute.values.length && attribute.values.length) {
-        throw new Error("Illegal values in attributes");
-      }
-      const classProperty = schemaClass?.properties[attribute.name];
-      if (classProperty) {
-        if (!table.properties) {
-          table.properties = {};
-        }
-        table.properties[attribute.name] = { values: 0, data: attribute.values };
-      }
+  var loadBasisEncoderPromise;
+  async function loadBasisEncoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basisEncoder) {
+      return modules.basisEncoder;
     }
-    table.count = count;
-    return table;
+    loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
+    return await loadBasisEncoderPromise;
   }
-  function createPropertyTableProperty(values, classProperty, scenegraph) {
-    const prop = { values: 0 };
-    if (classProperty.type === "STRING") {
-      const { stringData, stringOffsets } = createPropertyDataString(values);
-      prop.stringOffsets = createBufferView(stringOffsets, scenegraph);
-      prop.values = createBufferView(stringData, scenegraph);
-    } else if (classProperty.type === "SCALAR" && classProperty.componentType) {
-      const data = createPropertyDataScalar(values, classProperty.componentType);
-      prop.values = createBufferView(data, scenegraph);
+  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;
     }
-    return prop;
+    return new Promise((resolve2) => {
+      BasisEncoderModule(options).then((module) => {
+        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
+        initializeBasis();
+        resolve2({ BasisFile, KTX2File, BasisEncoder });
+      });
+    });
   }
-  var COMPONENT_TYPE_TO_ARRAY_CONSTRUCTOR = {
-    INT8: Int8Array,
-    UINT8: Uint8Array,
-    INT16: Int16Array,
-    UINT16: Uint16Array,
-    INT32: Int32Array,
-    UINT32: Uint32Array,
-    INT64: Int32Array,
-    UINT64: Uint32Array,
-    FLOAT32: Float32Array,
-    FLOAT64: Float64Array
+
+  // ../../node_modules/@loaders.gl/gltf/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/gltf/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-rgb-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-rgb2unorm-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 */
   };
-  function createPropertyDataScalar(array, componentType) {
-    const numberArray = [];
-    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");
+  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 new Construct(numberArray);
+    return textureFormats;
   }
-  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;
+  function getWebGLContext() {
+    try {
+      const canvas = document.createElement("canvas");
+      return canvas.getContext("webgl");
+    } catch (error) {
+      return null;
     }
-    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/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/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;
+  // ../../node_modules/@loaders.gl/gltf/node_modules/@loaders.gl/textures/dist/lib/parsers/parse-basis.js
+  var basisTranscodingLock = Promise.resolve();
+  var BASIS_FORMAT_TO_OUTPUT_OPTIONS = {
+    etc1: {
+      basisFormat: 0,
+      compressed: true,
+      format: GL_COMPRESSED_RGB_ETC1_WEBGL,
+      textureFormat: "etc1-rgb-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"
     }
-    if (options.gltf?.loadImages) {
-      decodePropertyTextures2(scenegraph, extension);
+  };
+  var BASIS_FORMATS = Object.freeze(Object.keys(BASIS_FORMAT_TO_OUTPUT_OPTIONS));
+  async function withBasisTranscodingLock(transcode) {
+    const previousLock = basisTranscodingLock;
+    let releaseLock;
+    basisTranscodingLock = new Promise((resolve2) => {
+      releaseLock = resolve2;
+    });
+    await previousLock;
+    try {
+      return await transcode();
+    } finally {
+      releaseLock();
     }
-    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);
+  async function parseBasis(data, options = {}) {
+    const loadLibraryOptions = extractLoadLibraryOptions(options);
+    return await withBasisTranscodingLock(async () => {
+      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);
       }
-    }
-  }
-  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);
-        }
+      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 findPropertyTableByClass2(propertyTables, schemaClassName) {
-    for (const propertyTableName in propertyTables) {
-      const propertyTable = propertyTables[propertyTableName];
-      if (propertyTable.class === schemaClassName) {
-        return propertyTable;
+  function parseBasisFile(BasisFile, data, options) {
+    const basisFile = new BasisFile(new Uint8Array(data));
+    try {
+      if (!basisFile.startTranscoding()) {
+        throw new Error("Failed to start basis transcoding");
       }
-    }
-    return null;
-  }
-  function findFeatureTextureByClass(featureTextures, schemaClassName) {
-    for (const featureTexturesName in featureTextures) {
-      const featureTable = featureTextures[featureTexturesName];
-      if (featureTable.class === schemaClassName) {
-        return featureTable;
+      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();
     }
-    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 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 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 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 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);
+  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 data;
+    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 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
-      );
+  function getBasisOptions(options, hasAlpha) {
+    let format = options.basis?.format || "auto";
+    if (format === "auto") {
+      format = options.basis?.supportedTextureFormats ? selectSupportedBasisFormat(options.basis.supportedTextureFormats) : selectSupportedBasisFormat();
     }
-    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
-      );
+    if (typeof format === "object") {
+      format = hasAlpha ? format.alpha : format.noAlpha;
     }
-    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 normalizedFormat = format.toLowerCase();
+    const basisOutputOptions = BASIS_FORMAT_TO_OUTPUT_OPTIONS[normalizedFormat];
+    if (!basisOutputOptions) {
+      throw new Error(`Unknown Basis format ${format}`);
     }
-    return valuesData;
+    return basisOutputOptions;
   }
-  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);
-      }
+  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-rgb2unorm-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-rgb-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 featureTextureTable;
+    return "rgb565";
   }
-  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 hasSupportedTextureFormat(supportedTextureFormats, candidateTextureFormats) {
+    return candidateTextureFormats.some((textureFormat) => supportedTextureFormats.has(textureFormat));
   }
 
-  // ../../node_modules/@loaders.gl/gltf/dist/lib/utils/version.js
-  var VERSION11 = true ? "4.4.1" : "latest";
+  // ../../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",
+        containerFormat: "auto",
+        module: "transcoder"
+      }
+    }
+  };
+  var BasisLoader = {
+    ...BasisWorkerLoader,
+    parse: parseBasis
+  };
 
   // ../../node_modules/@loaders.gl/gltf/dist/lib/parsers/parse-glb.js
   var LITTLE_ENDIAN2 = true;
@@ -28907,7 +28907,7 @@ void main(void) {
     name: "glTF",
     id: "gltf",
     module: "gltf",
-    version: VERSION11,
+    version: VERSION10,
     extensions: ["gltf", "glb"],
     mimeTypes: ["model/gltf+json", "model/gltf-binary"],
     text: true,
@@ -29672,7 +29672,7 @@ void main(void) {
     id: "3d-tiles-subtree",
     name: "3D Tiles Subtree",
     module: "3d-tiles",
-    version: VERSION9,
+    version: VERSION8,
     extensions: ["subtree"],
     mimeTypes: ["application/octet-stream"],
     tests: ["subtree"],
@@ -31259,7 +31259,7 @@ void main(void) {
     id: "3d-tiles",
     name: "3D Tiles",
     module: "3d-tiles",
-    version: VERSION9,
+    version: VERSION8,
     extensions: ["cmpt", "pnts", "b3dm", "i3dm"],
     mimeTypes: ["application/octet-stream"],
     tests: ["cmpt", "pnts", "b3dm", "i3dm"],
@@ -31654,7 +31654,6 @@ void main(void) {
   // src/terrain-layer/terrain-layer.ts
   var import_core49 = __toESM(require_core(), 1);
   var import_mesh_layers3 = __toESM(require_mesh_layers(), 1);
-  var import_core50 = __toESM(require_core(), 1);
 
   // ../../node_modules/@loaders.gl/terrain/dist/lib/decode-quantized-mesh.js
   var QUANTIZED_MESH_HEADER = /* @__PURE__ */ new Map([
@@ -32615,7 +32614,7 @@ void main(void) {
   }
 
   // ../../node_modules/@loaders.gl/terrain/dist/lib/utils/version.js
-  var VERSION12 = true ? "4.4.1" : "latest";
+  var VERSION12 = true ? "4.4.3" : "latest";
 
   // ../../node_modules/@loaders.gl/terrain/dist/terrain-loader.js
   var TerrainLoader = {
@@ -32807,7 +32806,7 @@ void main(void) {
         mesh,
         texture,
         _instanced: false,
-        coordinateSystem: import_core50.COORDINATE_SYSTEM.CARTESIAN,
+        coordinateSystem: import_core49.COORDINATE_SYSTEM.CARTESIAN,
         getPosition: (d2) => [0, 0, 0],
         getColor: color,
         wireframe,
@@ -32852,7 +32851,8 @@ void main(void) {
         onTileError,
         maxCacheSize,
         maxCacheByteSize,
-        refinementStrategy
+        refinementStrategy,
+        zoomOffset
       } = this.props;
       if (this.state.isTiled) {
         return new TileLayer(
@@ -32867,7 +32867,9 @@ void main(void) {
                 elevationData: urlTemplateToUpdateTrigger(elevationData),
                 texture: urlTemplateToUpdateTrigger(texture),
                 meshMaxError,
-                elevationDecoder
+                elevationDecoder,
+                projectionMode: this.context.viewport.projectionMode,
+                zoomOffset
               }
             },
             onViewportLoad: this.onViewportLoad.bind(this),
@@ -32882,7 +32884,8 @@ void main(void) {
             onTileError,
             maxCacheSize,
             maxCacheByteSize,
-            refinementStrategy
+            refinementStrategy,
+            zoomOffset
           }
         );
       }
@@ -32912,7 +32915,7 @@ void main(void) {
   var isTileSetURL = (url) => url.includes("{x}") && (url.includes("{y}") || url.includes("{-y}"));
 
   // src/mvt-layer/mvt-layer.ts
-  var import_core52 = __toESM(require_core(), 1);
+  var import_core51 = __toESM(require_core(), 1);
   var import_layers9 = __toESM(require_layers(), 1);
   var import_extensions = __toESM(require_extensions(), 1);
 
@@ -34487,7 +34490,7 @@ void main(void) {
   };
 
   // ../../node_modules/@loaders.gl/mvt/dist/mvt-loader.js
-  var VERSION13 = true ? "4.4.1" : "latest";
+  var VERSION13 = true ? "4.4.3" : "latest";
   var MVTWorkerLoader = {
     ...MVTFormat,
     dataType: null,
@@ -34768,12 +34771,12 @@ void main(void) {
       if (!this.context.viewport.resolution) {
         props.modelMatrix = modelMatrix;
         props.coordinateOrigin = [xOffset, yOffset, 0];
-        props.coordinateSystem = import_core52.COORDINATE_SYSTEM.CARTESIAN;
+        props.coordinateSystem = import_core51.COORDINATE_SYSTEM.CARTESIAN;
         props.extensions = [...props.extensions || [], new import_extensions.ClipExtension()];
       }
       const subLayers = super.renderSubLayers(props);
       if (this.state.binary && !(subLayers instanceof import_layers9.GeoJsonLayer)) {
-        import_core52.log.warn("renderSubLayers() must return GeoJsonLayer when using binary:true")();
+        import_core51.log.warn("renderSubLayers() must return GeoJsonLayer when using binary:true")();
       }
       return subLayers;
     }