@loaders.gl/textures 4.4.0-alpha.17 → 4.4.0-alpha.19

package/dist/index.cjs

@@ -96,12 +96,18 @@ __export(dist_exports, {
   GL_RGB565: () => GL_RGB565,
   GL_RGB5_A1: () => GL_RGB5_A1,
   GL_RGBA: () => GL_RGBA,
+  GL_RGBA32F: () => GL_RGBA32F,
   GL_RGBA4: () => GL_RGBA4,
   GL_RGBA8: () => GL_RGBA8,
   KTX2BasisWriter: () => KTX2BasisWriter,
   KTX2BasisWriterWorker: () => KTX2BasisWriterWorker,
   NPYLoader: () => NPYLoader,
   NPYWorkerLoader: () => NPYWorkerLoader,
+  RadianceHDRLoader: () => RadianceHDRLoader,
+  TextureArrayLoader: () => TextureArrayLoader,
+  TextureCubeArrayLoader: () => TextureCubeArrayLoader,
+  TextureCubeLoader: () => TextureCubeLoader,
+  TextureLoader: () => TextureLoader,
   loadImageTexture: () => loadImageTexture,
   loadImageTextureArray: () => loadImageTextureArray,
   loadImageTextureCube: () => loadImageTextureCube
@@ -109,7 +115,10 @@ __export(dist_exports, {
 module.exports = __toCommonJS(dist_exports);
 
 // dist/lib/utils/version.js
-var VERSION = true ? "4.4.0-alpha.17" : "latest";
+var VERSION = true ? "4.4.0-alpha.19" : "latest";
+
+// dist/lib/parsers/parse-basis.js
+var import_worker_utils2 = require("@loaders.gl/worker-utils");
 
 // dist/lib/parsers/basis-module-loader.js
 var import_loader_utils = require("@loaders.gl/loader-utils");
@@ -197,6 +206,7 @@ var GL_RGBA4 = 32854;
 var GL_RGB5_A1 = 32855;
 var GL_RGBA8 = 32856;
 var GL_RGB565 = 36194;
+var GL_RGBA32F = 34836;
 var GL_COMPRESSED_RGB_S3TC_DXT1_EXT = 33776;
 var GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = 33777;
 var GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = 33778;
@@ -266,6 +276,7 @@ var GL_EXTENSIONS_CONSTANTS = {
   RGB5_A1: GL_RGB5_A1,
   RGBA8: GL_RGBA8,
   RGB565: GL_RGB565,
+  RGBA32F: GL_RGBA32F,
   COMPRESSED_RGB_S3TC_DXT1_EXT: GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
   COMPRESSED_RGBA_S3TC_DXT1_EXT: GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
   COMPRESSED_RGBA_S3TC_DXT3_EXT: GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
@@ -382,7 +393,7 @@ var WEBGL_TEXTURE_FORMATS = {
     "bc7-rgba-unorm",
     "bc7-rgba-unorm-srgb"
   ],
-  WEBGL_compressed_texture_etc1: ["etc1-rbg-unorm-webgl"],
+  WEBGL_compressed_texture_etc1: ["etc1-rgb-unorm-webgl"],
   WEBGL_compressed_texture_etc: [
     "etc2-rgb8unorm",
     "etc2-rgb8unorm-srgb",
@@ -398,7 +409,7 @@ var WEBGL_TEXTURE_FORMATS = {
   WEBGL_compressed_texture_pvrtc: [
     "pvrtc-rgb4unorm-webgl",
     "pvrtc-rgba4unorm-webgl",
-    "pvrtc-rbg2unorm-webgl",
+    "pvrtc-rgb2unorm-webgl",
     "pvrtc-rgba2unorm-webgl"
   ],
   WEBGL_compressed_texture_atc: [
@@ -470,6 +481,7 @@ var import_ktx_parse = require("ktx-parse");
 
 // dist/lib/utils/texture-format-map.js
 var WEBGL_TO_TEXTURE_FORMAT = {
+  [GL_RGBA32F]: "rgba32float",
   [GL_COMPRESSED_RGB_S3TC_DXT1_EXT]: "bc1-rgb-unorm-webgl",
   [GL_COMPRESSED_SRGB_S3TC_DXT1_EXT]: "bc1-rgb-unorm-srgb-webgl",
   [GL_COMPRESSED_RGBA_S3TC_DXT1_EXT]: "bc1-rgba-unorm",
@@ -522,25 +534,35 @@ var WEBGL_TO_TEXTURE_FORMAT = {
   [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR]: "astc-12x12-unorm-srgb",
   [GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG]: "pvrtc-rgb4unorm-webgl",
   [GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG]: "pvrtc-rgba4unorm-webgl",
-  [GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG]: "pvrtc-rbg2unorm-webgl",
+  [GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG]: "pvrtc-rgb2unorm-webgl",
   [GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG]: "pvrtc-rgba2unorm-webgl",
-  [GL_COMPRESSED_RGB_ETC1_WEBGL]: "etc1-rbg-unorm-webgl",
+  [GL_COMPRESSED_RGB_ETC1_WEBGL]: "etc1-rgb-unorm-webgl",
   [GL_COMPRESSED_RGB_ATC_WEBGL]: "atc-rgb-unorm-webgl",
   [GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL]: "atc-rgba-unorm-webgl",
   [GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL]: "atc-rgbai-unorm-webgl"
 };
+var TEXTURE_FORMAT_TO_WEBGL = Object.fromEntries(Object.entries(WEBGL_TO_TEXTURE_FORMAT).map(([format, textureFormat]) => [
+  textureFormat,
+  Number(format)
+]));
 function getTextureFormatFromWebGLFormat(format) {
   if (format === void 0) {
     return void 0;
   }
   return WEBGL_TO_TEXTURE_FORMAT[format];
 }
+function getWebGLFormatFromTextureFormat(textureFormat) {
+  if (textureFormat === void 0) {
+    return void 0;
+  }
+  return TEXTURE_FORMAT_TO_WEBGL[textureFormat];
+}
 
 // dist/lib/utils/extract-mipmap-images.js
 function extractMipmapImages(data, options) {
   const images = new Array(options.mipMapLevels);
-  const format = options.internalFormat;
-  const textureFormat = format === void 0 ? void 0 : getTextureFormatFromWebGLFormat(format);
+  const textureFormat = options.textureFormat || getTextureFormatFromWebGLFormat(options.internalFormat);
+  const format = options.internalFormat || getWebGLFormatFromTextureFormat(options.textureFormat);
   let levelWidth = options.width;
   let levelHeight = options.height;
   let offset = 0;
@@ -653,6 +675,9 @@ var VULKAN_TO_WEBGL_FORMAT_MAP = {
 function mapVkFormatToWebGL(vkFormat) {
   return VULKAN_TO_WEBGL_FORMAT_MAP[vkFormat];
 }
+function mapVkFormatToTextureFormat(vkFormat) {
+  return getTextureFormatFromWebGLFormat(mapVkFormatToWebGL(vkFormat));
+}
 
 // dist/lib/parsers/parse-ktx.js
 var KTX2_ID = [
@@ -692,26 +717,27 @@ function parseKTX(arrayBuffer) {
   const mipMapLevels = Math.max(1, ktx.levels.length);
   const width = ktx.pixelWidth;
   const height = ktx.pixelHeight;
-  const internalFormat = mapVkFormatToWebGL(ktx.vkFormat);
-  if (internalFormat === void 0) {
-    import_loader_utils2.log.warn(`KTX2 container vkFormat ${ktx.vkFormat} does not map to a known WebGL format; returning texture levels without format metadata.`)();
+  const textureFormat = mapVkFormatToTextureFormat(ktx.vkFormat);
+  if (textureFormat === void 0) {
+    import_loader_utils2.log.warn(`KTX2 container vkFormat ${ktx.vkFormat} does not map to a known texture format; returning texture levels without format metadata.`)();
   }
   return extractMipmapImages(ktx.levels, {
     mipMapLevels,
     width,
     height,
     sizeFunction: (level) => level.uncompressedByteLength,
-    internalFormat
+    textureFormat
   });
 }
 
 // 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-rbg-unorm-webgl"
+    textureFormat: "etc1-rgb-unorm-webgl"
   },
   etc2: {
     basisFormat: 1,
@@ -811,31 +837,47 @@ var BASIS_FORMAT_TO_OUTPUT_OPTIONS = {
   }
 };
 var BASIS_FORMATS = Object.freeze(Object.keys(BASIS_FORMAT_TO_OUTPUT_OPTIONS));
+async function withBasisTranscodingLock(transcode) {
+  const previousLock = basisTranscodingLock;
+  let releaseLock;
+  basisTranscodingLock = new Promise((resolve) => {
+    releaseLock = resolve;
+  });
+  await previousLock;
+  try {
+    return await transcode();
+  } finally {
+    releaseLock();
+  }
+}
 async function parseBasis(data, options = {}) {
-  var _a;
-  if (!((_a = options.basis) == null ? void 0 : _a.containerFormat) || options.basis.containerFormat === "auto") {
-    if (isKTX(data)) {
-      const fileConstructors = await loadBasisEncoderModule((options == null ? void 0 : options.core) || {});
-      return parseKTX2File(fileConstructors.KTX2File, data, options);
-    }
-    const { BasisFile } = await loadBasisTranscoderModule((options == null ? void 0 : options.core) || {});
-    return parseBasisFile(BasisFile, data, options);
-  }
-  switch (options.basis.module) {
-    case "encoder":
-      const fileConstructors = await loadBasisEncoderModule((options == null ? void 0 : options.core) || {});
-      switch (options.basis.containerFormat) {
-        case "ktx2":
-          return parseKTX2File(fileConstructors.KTX2File, data, options);
-        case "basis":
-        default:
-          return parseBasisFile(fileConstructors.BasisFile, data, options);
+  const loadLibraryOptions = (0, import_worker_utils2.extractLoadLibraryOptions)(options);
+  return await withBasisTranscodingLock(async () => {
+    var _a;
+    if (!((_a = options.basis) == null ? void 0 : _a.containerFormat) || options.basis.containerFormat === "auto") {
+      if (isKTX(data)) {
+        const fileConstructors = await loadBasisEncoderModule(loadLibraryOptions);
+        return parseKTX2File(fileConstructors.KTX2File, data, options);
       }
-    case "transcoder":
-    default:
-      const { BasisFile } = await loadBasisTranscoderModule(options.core || {});
+      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));
@@ -976,7 +1018,7 @@ function selectSupportedBasisFormat(supportedTextureFormats = detectSupportedTex
   } else if (hasSupportedTextureFormat(textureFormats2, [
     "pvrtc-rgb4unorm-webgl",
     "pvrtc-rgba4unorm-webgl",
-    "pvrtc-rbg2unorm-webgl",
+    "pvrtc-rgb2unorm-webgl",
     "pvrtc-rgba2unorm-webgl"
   ])) {
     return {
@@ -996,7 +1038,7 @@ function selectSupportedBasisFormat(supportedTextureFormats = detectSupportedTex
     "eac-rg11snorm"
   ])) {
     return "etc2";
-  } else if (textureFormats2.has("etc1-rbg-unorm-webgl")) {
+  } else if (textureFormats2.has("etc1-rgb-unorm-webgl")) {
     return "etc1";
   } else if (hasSupportedTextureFormat(textureFormats2, [
     "atc-rgb-unorm-webgl",
@@ -1030,7 +1072,6 @@ var BasisWorkerLoader = {
   options: {
     basis: {
       format: "auto",
-      libraryPath: "libs/",
       containerFormat: "auto",
       module: "transcoder"
     }
@@ -1057,13 +1098,13 @@ var DDS_CONSTANTS = {
   DDSD_MIPMAPCOUNT: 131072,
   DDPF_FOURCC: 4
 };
-var DDS_PIXEL_FORMATS = {
-  DXT1: GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
-  DXT3: GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
-  DXT5: GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
-  "ATC ": GL_COMPRESSED_RGB_ATC_WEBGL,
-  ATCA: GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
-  ATCI: GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL
+var DDS_TEXTURE_FORMATS = {
+  DXT1: "bc1-rgb-unorm-webgl",
+  DXT3: "bc2-rgba-unorm",
+  DXT5: "bc3-rgba-unorm",
+  "ATC ": "atc-rgb-unorm-webgl",
+  ATCA: "atc-rgba-unorm-webgl",
+  ATCI: "atc-rgbai-unorm-webgl"
 };
 var getATCLevelSize = getDxt1LevelSize;
 var getATCALevelSize = getDxtXLevelSize;
@@ -1086,9 +1127,9 @@ function parseDDS(data) {
   const pixelFormatNumber = header[DDS_CONSTANTS.HEADER_PF_FOURCC_INDEX];
   (0, import_loader_utils3.assert)(Boolean(header[DDS_CONSTANTS.HEADER_PF_FLAGS_INDEX] & DDS_CONSTANTS.DDPF_FOURCC), "DDS: Unsupported format, must contain a FourCC code");
   const fourCC = int32ToFourCC(pixelFormatNumber);
-  const internalFormat = DDS_PIXEL_FORMATS[fourCC];
+  const textureFormat = DDS_TEXTURE_FORMATS[fourCC];
   const sizeFunction = DDS_SIZE_FUNCTIONS[fourCC];
-  (0, import_loader_utils3.assert)(internalFormat && sizeFunction, `DDS: Unknown pixel format ${pixelFormatNumber}`);
+  (0, import_loader_utils3.assert)(textureFormat && sizeFunction, `DDS: Unknown pixel format ${pixelFormatNumber}`);
   let mipMapLevels = 1;
   if (header[DDS_CONSTANTS.HEADER_FLAGS_INDEX] & DDS_CONSTANTS.DDSD_MIPMAPCOUNT) {
     mipMapLevels = Math.max(1, header[DDS_CONSTANTS.MIPMAPCOUNT_INDEX]);
@@ -1102,7 +1143,7 @@ function parseDDS(data) {
     width,
     height,
     sizeFunction,
-    internalFormat
+    textureFormat
   });
 }
 function getDxt1LevelSize(width, height) {
@@ -1129,34 +1170,34 @@ var PVR_CONSTANTS = {
   MIPMAPCOUNT_INDEX: 11,
   METADATA_SIZE_INDEX: 12
 };
-var PVR_PIXEL_FORMATS = {
-  0: [GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG],
-  1: [GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG],
-  2: [GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG],
-  3: [GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG],
-  6: [GL_COMPRESSED_RGB_ETC1_WEBGL],
-  7: [GL_COMPRESSED_RGB_S3TC_DXT1_EXT],
-  9: [GL_COMPRESSED_RGBA_S3TC_DXT3_EXT],
-  11: [GL_COMPRESSED_RGBA_S3TC_DXT5_EXT],
-  22: [GL_COMPRESSED_RGB8_ETC2],
-  23: [GL_COMPRESSED_RGBA8_ETC2_EAC],
-  24: [GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2],
-  25: [GL_COMPRESSED_R11_EAC],
-  26: [GL_COMPRESSED_RG11_EAC],
-  27: [GL_COMPRESSED_RGBA_ASTC_4x4_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR],
-  28: [GL_COMPRESSED_RGBA_ASTC_5x4_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR],
-  29: [GL_COMPRESSED_RGBA_ASTC_5x5_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR],
-  30: [GL_COMPRESSED_RGBA_ASTC_6x5_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR],
-  31: [GL_COMPRESSED_RGBA_ASTC_6x6_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR],
-  32: [GL_COMPRESSED_RGBA_ASTC_8x5_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR],
-  33: [GL_COMPRESSED_RGBA_ASTC_8x6_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR],
-  34: [GL_COMPRESSED_RGBA_ASTC_8x8_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR],
-  35: [GL_COMPRESSED_RGBA_ASTC_10x5_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR],
-  36: [GL_COMPRESSED_RGBA_ASTC_10x6_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR],
-  37: [GL_COMPRESSED_RGBA_ASTC_10x8_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR],
-  38: [GL_COMPRESSED_RGBA_ASTC_10x10_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR],
-  39: [GL_COMPRESSED_RGBA_ASTC_12x10_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR],
-  40: [GL_COMPRESSED_RGBA_ASTC_12x12_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR]
+var PVR_TEXTURE_FORMATS = {
+  0: ["pvrtc-rgb2unorm-webgl"],
+  1: ["pvrtc-rgba2unorm-webgl"],
+  2: ["pvrtc-rgb4unorm-webgl"],
+  3: ["pvrtc-rgba4unorm-webgl"],
+  6: ["etc1-rgb-unorm-webgl"],
+  7: ["bc1-rgb-unorm-webgl"],
+  9: ["bc2-rgba-unorm"],
+  11: ["bc3-rgba-unorm"],
+  22: ["etc2-rgb8unorm"],
+  23: ["etc2-rgba8unorm"],
+  24: ["etc2-rgb8a1unorm"],
+  25: ["eac-r11unorm"],
+  26: ["eac-rg11unorm"],
+  27: ["astc-4x4-unorm", "astc-4x4-unorm-srgb"],
+  28: ["astc-5x4-unorm", "astc-5x4-unorm-srgb"],
+  29: ["astc-5x5-unorm", "astc-5x5-unorm-srgb"],
+  30: ["astc-6x5-unorm", "astc-6x5-unorm-srgb"],
+  31: ["astc-6x6-unorm", "astc-6x6-unorm-srgb"],
+  32: ["astc-8x5-unorm", "astc-8x5-unorm-srgb"],
+  33: ["astc-8x6-unorm", "astc-8x6-unorm-srgb"],
+  34: ["astc-8x8-unorm", "astc-8x8-unorm-srgb"],
+  35: ["astc-10x5-unorm", "astc-10x5-unorm-srgb"],
+  36: ["astc-10x6-unorm", "astc-10x6-unorm-srgb"],
+  37: ["astc-10x8-unorm", "astc-10x8-unorm-srgb"],
+  38: ["astc-10x10-unorm", "astc-10x10-unorm-srgb"],
+  39: ["astc-12x10-unorm", "astc-12x10-unorm-srgb"],
+  40: ["astc-12x12-unorm", "astc-12x12-unorm-srgb"]
 };
 var PVR_SIZE_FUNCTIONS = {
   0: pvrtc2bppSize,
@@ -1196,8 +1237,8 @@ function parsePVR(data) {
   const header = new Uint32Array(data, 0, PVR_CONSTANTS.HEADER_LENGTH);
   const pvrFormat = header[PVR_CONSTANTS.PIXEL_FORMAT_INDEX];
   const colourSpace = header[PVR_CONSTANTS.COLOUR_SPACE_INDEX];
-  const pixelFormats = PVR_PIXEL_FORMATS[pvrFormat] || [];
-  const internalFormat = pixelFormats.length > 1 && colourSpace ? pixelFormats[1] : pixelFormats[0];
+  const textureFormats2 = PVR_TEXTURE_FORMATS[pvrFormat] || [];
+  const textureFormat = textureFormats2.length > 1 && colourSpace ? textureFormats2[1] : textureFormats2[0];
   const sizeFunction = PVR_SIZE_FUNCTIONS[pvrFormat];
   const mipMapLevels = header[PVR_CONSTANTS.MIPMAPCOUNT_INDEX];
   const width = header[PVR_CONSTANTS.WIDTH_INDEX];
@@ -1209,7 +1250,7 @@ function parsePVR(data) {
     width,
     height,
     sizeFunction,
-    internalFormat
+    textureFormat
   });
 }
 function pvrtc2bppSize(width, height) {
@@ -1309,7 +1350,6 @@ var CompressedTextureWorkerLoader = {
   binary: true,
   options: {
     "compressed-texture": {
-      libraryPath: "libs/",
       useBasis: false
     }
   }
@@ -1349,10 +1389,326 @@ var CrunchLoader = {
   mimeTypes: ["image/crn", "image/x-crn", "application/octet-stream"],
   binary: true,
   options: {
-    crunch: {
-      libraryPath: "libs/"
+    crunch: {}
+  }
+};
+
+// dist/lib/parsers/parse-hdr.js
+var HDR_MAGIC_HEADERS = ["#?RADIANCE", "#?RGBE"];
+var HDR_FORMAT = "32-bit_rle_rgbe";
+function isHDR(arrayBuffer) {
+  const state = {
+    data: new Uint8Array(arrayBuffer),
+    offset: 0
+  };
+  const firstLine = readLine(state);
+  return firstLine ? HDR_MAGIC_HEADERS.includes(firstLine) : false;
+}
+function parseHDR(arrayBuffer) {
+  const state = {
+    data: new Uint8Array(arrayBuffer),
+    offset: 0
+  };
+  const header = readHeader(state);
+  const { width, height } = header;
+  const rgbeData = readPixels(state, header);
+  const data = convertRGBEToFloat(rgbeData);
+  const level = {
+    shape: "texture-level",
+    compressed: false,
+    width,
+    height,
+    data,
+    levelSize: data.byteLength,
+    format: GL_RGBA32F,
+    textureFormat: "rgba32float"
+  };
+  return {
+    shape: "texture",
+    type: "2d",
+    format: "rgba32float",
+    ...header.metadata ? { metadata: header.metadata } : {},
+    data: [level]
+  };
+}
+function readHeader(state) {
+  const magicHeader = readLine(state);
+  if (!magicHeader || !HDR_MAGIC_HEADERS.includes(magicHeader)) {
+    throw new Error("RadianceHDRLoader: bad initial token");
+  }
+  let hasFormat = false;
+  const metadata = {};
+  while (state.offset < state.data.length) {
+    const line = readLine(state);
+    if (line === null) {
+      break;
+    }
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    if (line.startsWith("FORMAT=")) {
+      hasFormat = line.slice("FORMAT=".length) === HDR_FORMAT;
+      if (!hasFormat) {
+        throw new Error("RadianceHDRLoader: unsupported format specifier");
+      }
+      continue;
+    }
+    parseMetadataLine(metadata, line);
+    const dimensions = parseDimensions(line);
+    if (dimensions) {
+      if (!hasFormat) {
+        throw new Error("RadianceHDRLoader: missing format specifier");
+      }
+      return {
+        ...dimensions,
+        ...hasMetadata(metadata) ? { metadata } : {}
+      };
+    }
+  }
+  if (!hasFormat) {
+    throw new Error("RadianceHDRLoader: missing format specifier");
+  }
+  throw new Error("RadianceHDRLoader: missing image size specifier");
+}
+function parseDimensions(line) {
+  const match = line.match(/^([+-])([YX])\s+(\d+)\s+([+-])([YX])\s+(\d+)$/);
+  if (!match) {
+    return null;
+  }
+  const majorSign = match[1] === "+" ? 1 : -1;
+  const majorAxis = match[2];
+  const majorLength = Number(match[3]);
+  const minorSign = match[4] === "+" ? 1 : -1;
+  const minorAxis = match[5];
+  const minorLength = Number(match[6]);
+  if (majorAxis === minorAxis) {
+    throw new Error("RadianceHDRLoader: invalid image dimensions");
+  }
+  const width = majorAxis === "X" ? majorLength : minorLength;
+  const height = majorAxis === "Y" ? majorLength : minorLength;
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    throw new Error("RadianceHDRLoader: invalid image dimensions");
+  }
+  return { width, height, majorAxis, majorSign, minorAxis, minorSign };
+}
+function readPixels(state, header) {
+  const { width, height } = header;
+  const pixelCount = width * height;
+  const flatByteLength = pixelCount * 4;
+  const scanlineLength = header.minorAxis === "X" ? width : height;
+  const scanlineCount = header.majorAxis === "Y" ? height : width;
+  if (scanlineLength < 8 || scanlineLength > 32767) {
+    return reorderPixels(readFlatPixels(state, flatByteLength), header);
+  }
+  if (state.offset + 4 > state.data.length) {
+    throw new Error("RadianceHDRLoader: unexpected end of file");
+  }
+  const data = state.data;
+  const isRunLengthEncoded = data[state.offset] === 2 && data[state.offset + 1] === 2 && !(data[state.offset + 2] & 128);
+  if (!isRunLengthEncoded) {
+    return reorderPixels(readFlatPixels(state, flatByteLength), header);
+  }
+  const scanlineWidth = data[state.offset + 2] << 8 | data[state.offset + 3];
+  if (scanlineWidth !== scanlineLength) {
+    return reorderPixels(readFlatPixels(state, flatByteLength), header);
+  }
+  const pixels = new Uint8Array(flatByteLength);
+  const scanlineBuffer = new Uint8Array(scanlineLength * 4);
+  for (let scanlineIndex = 0; scanlineIndex < scanlineCount; scanlineIndex++) {
+    if (state.offset + 4 > data.length) {
+      throw new Error("RadianceHDRLoader: unexpected end of file");
+    }
+    const red = data[state.offset++];
+    const green = data[state.offset++];
+    const blue = data[state.offset++];
+    const exponent = data[state.offset++];
+    if (red !== 2 || green !== 2 || (blue << 8 | exponent) !== scanlineLength) {
+      throw new Error("RadianceHDRLoader: bad rgbe scanline format");
+    }
+    for (let channelIndex = 0; channelIndex < 4; channelIndex++) {
+      const channelOffset = channelIndex * scanlineLength;
+      const channelEnd = channelOffset + scanlineLength;
+      let pixelOffset = channelOffset;
+      while (pixelOffset < channelEnd) {
+        if (state.offset >= data.length) {
+          throw new Error("RadianceHDRLoader: unexpected end of file");
+        }
+        let count = data[state.offset++];
+        if (count > 128) {
+          count -= 128;
+          if (count === 0 || pixelOffset + count > channelEnd || state.offset >= data.length) {
+            throw new Error("RadianceHDRLoader: bad scanline data");
+          }
+          const value = data[state.offset++];
+          scanlineBuffer.fill(value, pixelOffset, pixelOffset + count);
+          pixelOffset += count;
+          continue;
+        }
+        if (count === 0 || pixelOffset + count > channelEnd || state.offset + count > data.length) {
+          throw new Error("RadianceHDRLoader: bad scanline data");
+        }
+        scanlineBuffer.set(data.subarray(state.offset, state.offset + count), pixelOffset);
+        pixelOffset += count;
+        state.offset += count;
+      }
+    }
+    for (let pixelIndex = 0; pixelIndex < scanlineLength; pixelIndex++) {
+      const outputOffset = getOutputOffset(header, scanlineIndex, pixelIndex);
+      pixels[outputOffset] = scanlineBuffer[pixelIndex];
+      pixels[outputOffset + 1] = scanlineBuffer[pixelIndex + scanlineLength];
+      pixels[outputOffset + 2] = scanlineBuffer[pixelIndex + scanlineLength * 2];
+      pixels[outputOffset + 3] = scanlineBuffer[pixelIndex + scanlineLength * 3];
+    }
+  }
+  return pixels;
+}
+function reorderPixels(data, header) {
+  const pixels = new Uint8Array(data.length);
+  const scanlineLength = header.minorAxis === "X" ? header.width : header.height;
+  const scanlineCount = header.majorAxis === "Y" ? header.height : header.width;
+  for (let scanlineIndex = 0; scanlineIndex < scanlineCount; scanlineIndex++) {
+    for (let pixelIndex = 0; pixelIndex < scanlineLength; pixelIndex++) {
+      const sourceOffset = (scanlineIndex * scanlineLength + pixelIndex) * 4;
+      const outputOffset = getOutputOffset(header, scanlineIndex, pixelIndex);
+      pixels[outputOffset] = data[sourceOffset];
+      pixels[outputOffset + 1] = data[sourceOffset + 1];
+      pixels[outputOffset + 2] = data[sourceOffset + 2];
+      pixels[outputOffset + 3] = data[sourceOffset + 3];
+    }
+  }
+  return pixels;
+}
+function getOutputOffset(header, scanlineIndex, pixelIndex) {
+  const majorCoordinate = getCoordinate(header.majorAxis === "X" ? header.width : header.height, header.majorSign, scanlineIndex);
+  const minorCoordinate = getCoordinate(header.minorAxis === "X" ? header.width : header.height, header.minorSign, pixelIndex);
+  const x = header.majorAxis === "X" ? majorCoordinate : minorCoordinate;
+  const y = header.majorAxis === "Y" ? majorCoordinate : minorCoordinate;
+  return ((header.height - 1 - y) * header.width + x) * 4;
+}
+function getCoordinate(length, sign, index) {
+  return sign === 1 ? index : length - 1 - index;
+}
+function readFlatPixels(state, byteLength) {
+  if (state.offset + byteLength > state.data.length) {
+    throw new Error("RadianceHDRLoader: unexpected end of file");
+  }
+  const pixels = state.data.slice(state.offset, state.offset + byteLength);
+  state.offset += byteLength;
+  return pixels;
+}
+function convertRGBEToFloat(data) {
+  const floatData = new Float32Array(data.length);
+  for (let sourceOffset = 0; sourceOffset < data.length; sourceOffset += 4) {
+    const exponent = data[sourceOffset + 3];
+    const destinationOffset = sourceOffset;
+    if (exponent > 0) {
+      const scale = Math.pow(2, exponent - 128) / 255;
+      floatData[destinationOffset] = data[sourceOffset] * scale;
+      floatData[destinationOffset + 1] = data[sourceOffset + 1] * scale;
+      floatData[destinationOffset + 2] = data[sourceOffset + 2] * scale;
     }
+    floatData[destinationOffset + 3] = 1;
   }
+  return floatData;
+}
+function readLine(state) {
+  if (state.offset >= state.data.length) {
+    return null;
+  }
+  const lineStart = state.offset;
+  while (state.offset < state.data.length) {
+    const byte = state.data[state.offset++];
+    if (byte === 10) {
+      const line2 = decodeASCII(state.data.subarray(lineStart, state.offset - 1));
+      return line2.endsWith("\r") ? line2.slice(0, -1) : line2;
+    }
+  }
+  const line = decodeASCII(state.data.subarray(lineStart, state.offset));
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+function decodeASCII(data) {
+  let line = "";
+  for (const byte of data) {
+    line += String.fromCharCode(byte);
+  }
+  return line;
+}
+function parseMetadataLine(metadata, line) {
+  if (line.startsWith("COLORCORR=")) {
+    const values = parseNumberList(line.slice("COLORCORR=".length), 3);
+    if (values) {
+      metadata.colorCorrection = values;
+    }
+    return;
+  }
+  if (line.startsWith("EXPOSURE=")) {
+    const value = parseNumber(line.slice("EXPOSURE=".length));
+    if (value !== null) {
+      metadata.exposure = value;
+    }
+    return;
+  }
+  if (line.startsWith("GAMMA=")) {
+    const value = parseNumber(line.slice("GAMMA=".length));
+    if (value !== null) {
+      metadata.gamma = value;
+    }
+    return;
+  }
+  if (line.startsWith("PIXASPECT=")) {
+    const value = parseNumber(line.slice("PIXASPECT=".length));
+    if (value !== null) {
+      metadata.pixelAspectRatio = value;
+    }
+    return;
+  }
+  if (line.startsWith("PRIMARIES=")) {
+    const values = parseNumberList(line.slice("PRIMARIES=".length), 8);
+    if (values) {
+      metadata.primaries = values;
+    }
+    return;
+  }
+  if (line.startsWith("SOFTWARE=")) {
+    metadata.software = line.slice("SOFTWARE=".length).trim();
+    return;
+  }
+  if (line.startsWith("VIEW=")) {
+    metadata.view = line.slice("VIEW=".length).trim();
+  }
+}
+function parseNumber(text) {
+  const value = Number(text.trim());
+  return Number.isFinite(value) ? value : null;
+}
+function parseNumberList(text, count) {
+  const values = text.trim().split(/\s+/).map((value) => Number(value));
+  if (values.length !== count || values.some((value) => !Number.isFinite(value))) {
+    return null;
+  }
+  return values;
+}
+function hasMetadata(metadata) {
+  return Object.keys(metadata).length > 0;
+}
+
+// dist/radiance-hdr-loader.js
+var RadianceHDRLoader = {
+  dataType: null,
+  batchType: null,
+  name: "Radiance HDR",
+  id: "hdr",
+  module: "textures",
+  version: VERSION,
+  extensions: ["hdr"],
+  mimeTypes: ["image/vnd.radiance", "image/x-hdr", "application/octet-stream"],
+  binary: true,
+  tests: [isHDR],
+  options: {
+    hdr: {}
+  },
+  parseSync: parseHDR,
+  parse: async (arrayBuffer) => parseHDR(arrayBuffer)
 };
 
 // dist/lib/parsers/parse-npy.js
@@ -1436,16 +1792,597 @@ var NPYLoader = {
   parse: async (arrayBuffer, options) => parseNPY(arrayBuffer, options)
 };
 
-// dist/lib/parsers/crunch-module-loader.js
+// dist/lib/composite-image/parse-composite-image.js
 var import_loader_utils4 = require("@loaders.gl/loader-utils");
-var import_worker_utils2 = require("@loaders.gl/worker-utils");
+var import_images = require("@loaders.gl/images");
+
+// dist/lib/texture-api/async-deep-map.js
+var isObject = (value) => value && typeof value === "object";
+async function asyncDeepMap(tree, func, options = {}) {
+  return await mapSubtree(tree, func, options);
+}
+async function mapSubtree(object, func, options) {
+  if (Array.isArray(object)) {
+    return await mapArray(object, func, options);
+  }
+  if (isObject(object)) {
+    return await mapObject(object, func, options);
+  }
+  const url = object;
+  return await func(url, options);
+}
+async function mapObject(object, func, options) {
+  const promises = [];
+  const values = {};
+  for (const key in object) {
+    const url = object[key];
+    const promise = mapSubtree(url, func, options).then((value) => {
+      values[key] = value;
+    });
+    promises.push(promise);
+  }
+  await Promise.all(promises);
+  return values;
+}
+async function mapArray(urlArray, func, options = {}) {
+  const promises = urlArray.map((url) => mapSubtree(url, func, options));
+  return await Promise.all(promises);
+}
+
+// dist/lib/composite-image/image-texture-cube.js
+var GL_TEXTURE_CUBE_MAP_POSITIVE_X = 34069;
+var GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 34070;
+var GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 34071;
+var GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 34072;
+var GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 34073;
+var GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 34074;
+var IMAGE_TEXTURE_CUBE_FACES = [
+  {
+    face: GL_TEXTURE_CUBE_MAP_POSITIVE_X,
+    name: "+X",
+    direction: "right",
+    axis: "x",
+    sign: "positive"
+  },
+  {
+    face: GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+    name: "-X",
+    direction: "left",
+    axis: "x",
+    sign: "negative"
+  },
+  { face: GL_TEXTURE_CUBE_MAP_POSITIVE_Y, name: "+Y", direction: "top", axis: "y", sign: "positive" },
+  {
+    face: GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+    name: "-Y",
+    direction: "bottom",
+    axis: "y",
+    sign: "negative"
+  },
+  {
+    face: GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
+    name: "+Z",
+    direction: "front",
+    axis: "z",
+    sign: "positive"
+  },
+  { face: GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, name: "-Z", direction: "back", axis: "z", sign: "negative" }
+];
+
+// dist/lib/composite-image/parse-composite-image.js
+async function parseCompositeImageManifest(text, expectedShape, options = {}, context) {
+  const manifest = parseCompositeImageManifestJSON(text);
+  if (manifest.shape !== expectedShape) {
+    throw new Error(`Expected ${expectedShape} manifest, got ${manifest.shape}`);
+  }
+  return await loadCompositeImageManifest(manifest, options, context);
+}
+function testCompositeImageManifestShape(text, shape) {
+  try {
+    return parseCompositeImageManifestJSON(text).shape === shape;
+  } catch {
+    return false;
+  }
+}
+async function loadCompositeImageManifest(manifest, options = {}, context) {
+  const normalizedOptions = normalizeCompositeImageManifestOptions(options);
+  const urlTree = await getCompositeImageUrlTree(manifest, normalizedOptions, context);
+  const imageData = await loadCompositeImageUrlTree(urlTree, normalizedOptions, context);
+  return convertCompositeImageToTexture(manifest.shape, imageData);
+}
+async function loadCompositeImageUrlTree(urlTree, options = {}, context) {
+  const normalizedOptions = normalizeCompositeImageOptions(options);
+  return await asyncDeepMap(urlTree, async (url) => await loadCompositeImageMember(url, normalizedOptions, context));
+}
+async function loadCompositeImageMember(url, options = {}, context) {
+  const resolvedUrl = resolveCompositeImageUrl(url, options, context);
+  const fetch2 = getCompositeImageFetch(options, context);
+  const response = await fetch2(resolvedUrl);
+  const subloaderOptions = getCompositeImageSubloaderOptions(options);
+  if (context) {
+    const childContext = getCompositeImageMemberContext(resolvedUrl, response, context);
+    return await (0, import_loader_utils4.parseFromContext)(response, [import_images.ImageLoader], subloaderOptions, childContext);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  return await import_images.ImageLoader.parse(arrayBuffer, subloaderOptions);
+}
+async function getCompositeImageUrlTree(manifest, options = {}, context) {
+  switch (manifest.shape) {
+    case "image-texture":
+      return await getImageTextureSource(manifest, options, context);
+    case "image-texture-array":
+      if (!Array.isArray(manifest.layers) || manifest.layers.length === 0) {
+        throw new Error("image-texture-array manifest must define one or more layers");
+      }
+      return await Promise.all(manifest.layers.map(async (layer, index) => await getNormalizedImageTextureSource(layer, options, context, { index })));
+    case "image-texture-cube":
+      return await getImageTextureCubeUrls(manifest, options, context);
+    case "image-texture-cube-array":
+      if (!Array.isArray(manifest.layers) || manifest.layers.length === 0) {
+        throw new Error("image-texture-cube-array manifest must define one or more layers");
+      }
+      return await Promise.all(manifest.layers.map(async (layer, index) => await getImageTextureCubeUrls(layer, options, context, { index })));
+    default:
+      throw new Error("Unsupported composite image manifest");
+  }
+}
+function normalizeCompositeImageOptions(options = {}) {
+  var _a;
+  if ((_a = options.core) == null ? void 0 : _a.baseUrl) {
+    return options;
+  }
+  const fallbackBaseUrl = options.baseUrl;
+  if (!fallbackBaseUrl) {
+    return options;
+  }
+  return {
+    ...options,
+    core: {
+      ...options.core,
+      baseUrl: fallbackBaseUrl
+    }
+  };
+}
+function resolveCompositeImageUrl(url, options = {}, context) {
+  const resolvedUrl = (0, import_loader_utils4.resolvePath)(url);
+  if (isAbsoluteCompositeImageUrl(url)) {
+    return resolvedUrl;
+  }
+  const baseUrl = getCompositeImageBaseUrl(options, context);
+  if (!baseUrl) {
+    if (resolvedUrl !== url || url.startsWith("@")) {
+      return resolvedUrl;
+    }
+    throw new Error(`Unable to resolve relative image URL ${url} without a base URL`);
+  }
+  return (0, import_loader_utils4.resolvePath)(joinCompositeImageUrl(baseUrl, url));
+}
+function parseCompositeImageManifestJSON(text) {
+  const manifest = JSON.parse(text);
+  if (!(manifest == null ? void 0 : manifest.shape)) {
+    throw new Error("Composite image manifest must contain a shape field");
+  }
+  return manifest;
+}
+async function getImageTextureSource(manifest, options, context) {
+  var _a;
+  if ((manifest.image || manifest.mipmaps) && manifest.template) {
+    throw new Error("image-texture manifest must define image, mipmaps, or template source");
+  }
+  if (manifest.image && manifest.mipmaps) {
+    throw new Error("image-texture manifest must define image, mipmaps, or template source");
+  }
+  if (manifest.image) {
+    return manifest.image;
+  }
+  if ((_a = manifest.mipmaps) == null ? void 0 : _a.length) {
+    return manifest.mipmaps;
+  }
+  if (manifest.template) {
+    return await expandImageTextureSource({ mipLevels: manifest.mipLevels ?? "auto", template: manifest.template }, options, context, {});
+  }
+  throw new Error("image-texture manifest must define image, mipmaps, or template source");
+}
+async function getImageTextureCubeUrls(manifest, options, context, templateOptions = {}) {
+  var _a, _b;
+  const urls = {};
+  for (const { face, name, direction, axis, sign } of IMAGE_TEXTURE_CUBE_FACES) {
+    const source = ((_a = manifest.faces) == null ? void 0 : _a[name]) || ((_b = manifest.faces) == null ? void 0 : _b[direction]);
+    if (!source) {
+      throw new Error(`image-texture-cube manifest is missing ${name} face`);
+    }
+    urls[face] = await getNormalizedImageTextureSource(source, options, context, {
+      ...templateOptions,
+      face: name,
+      direction,
+      axis,
+      sign
+    });
+  }
+  return urls;
+}
+async function getNormalizedImageTextureSource(source, options, context, templateOptions) {
+  if (typeof source === "string") {
+    return source;
+  }
+  if (Array.isArray(source) && source.length > 0) {
+    return source;
+  }
+  if (isImageTextureTemplateSource(source)) {
+    return await expandImageTextureSource(source, options, context, templateOptions);
+  }
+  throw new Error("Composite image source entries must be strings or non-empty mip arrays");
+}
+async function expandImageTextureSource(source, options, context, templateOptions) {
+  const mipLevels = source.mipLevels === "auto" ? await getAutoMipLevels(source.template, options, context, templateOptions) : source.mipLevels;
+  if (!Number.isFinite(mipLevels) || mipLevels <= 0) {
+    throw new Error(`Invalid mipLevels value ${source.mipLevels}`);
+  }
+  const urls = [];
+  for (let lod = 0; lod < mipLevels; lod++) {
+    urls.push(expandTemplate(source.template, { ...templateOptions, lod }));
+  }
+  return urls;
+}
+async function getAutoMipLevels(template, options, context, templateOptions) {
+  if (!template.includes("{lod}")) {
+    throw new Error("Template sources with mipLevels: auto must include a {lod} placeholder");
+  }
+  const level0Url = expandTemplate(template, { ...templateOptions, lod: 0 });
+  const image = await loadCompositeImageMember(level0Url, normalizeCompositeImageOptions(options), context);
+  const { width, height } = (0, import_images.getImageSize)(image);
+  return 1 + Math.floor(Math.log2(Math.max(width, height)));
+}
+function expandTemplate(template, templateOptions) {
+  let expanded = "";
+  for (let index = 0; index < template.length; index++) {
+    const character = template[index];
+    if (character === "\\") {
+      const nextCharacter = template[index + 1];
+      if (nextCharacter === "{" || nextCharacter === "}" || nextCharacter === "\\") {
+        expanded += nextCharacter;
+        index++;
+        continue;
+      }
+      throw new Error(`Invalid escape sequence \\${nextCharacter || ""} in template ${template}`);
+    }
+    if (character === "}") {
+      throw new Error(`Unexpected } in template ${template}`);
+    }
+    if (character !== "{") {
+      expanded += character;
+      continue;
+    }
+    const closingBraceIndex = findClosingBraceIndex(template, index + 1);
+    if (closingBraceIndex < 0) {
+      throw new Error(`Unterminated placeholder in template ${template}`);
+    }
+    const placeholder = template.slice(index + 1, closingBraceIndex);
+    if (!/^[a-z][a-zA-Z0-9]*$/.test(placeholder)) {
+      throw new Error(`Invalid placeholder {${placeholder}} in template ${template}`);
+    }
+    const value = getTemplateValue(placeholder, templateOptions);
+    if (value === void 0) {
+      throw new Error(`Template ${template} uses unsupported placeholder {${placeholder}} for this source`);
+    }
+    expanded += String(value);
+    index = closingBraceIndex;
+  }
+  return expanded;
+}
+function findClosingBraceIndex(template, startIndex) {
+  for (let index = startIndex; index < template.length; index++) {
+    const character = template[index];
+    if (character === "\\") {
+      index++;
+      continue;
+    }
+    if (character === "{") {
+      throw new Error(`Nested placeholders are not supported in template ${template}`);
+    }
+    if (character === "}") {
+      return index;
+    }
+  }
+  return -1;
+}
+function getTemplateValue(placeholder, templateOptions) {
+  switch (placeholder) {
+    case "lod":
+      return templateOptions.lod;
+    case "index":
+      return templateOptions.index;
+    case "face":
+      return templateOptions.face;
+    case "direction":
+      return templateOptions.direction;
+    case "axis":
+      return templateOptions.axis;
+    case "sign":
+      return templateOptions.sign;
+    default:
+      return void 0;
+  }
+}
+function isImageTextureTemplateSource(source) {
+  return typeof source === "object" && source !== null && !Array.isArray(source);
+}
+function getCompositeImageBaseUrl(options, context) {
+  var _a;
+  if (context == null ? void 0 : context.baseUrl) {
+    return context.baseUrl;
+  }
+  if (options.baseUrl) {
+    return stripTrailingSlash(options.baseUrl);
+  }
+  if ((_a = options.core) == null ? void 0 : _a.baseUrl) {
+    return getSourceUrlDirectory(options.core.baseUrl);
+  }
+  return null;
+}
+function stripTrailingSlash(baseUrl) {
+  if (baseUrl.endsWith("/")) {
+    return baseUrl.slice(0, -1);
+  }
+  return baseUrl;
+}
+function getSourceUrlDirectory(baseUrl) {
+  return stripTrailingSlash(import_loader_utils4.path.dirname(baseUrl));
+}
+function joinCompositeImageUrl(baseUrl, url) {
+  if (isRequestLikeUrl(baseUrl)) {
+    return new URL(url, `${stripTrailingSlash(baseUrl)}/`).toString();
+  }
+  const normalizedBaseUrl = baseUrl.startsWith("/") ? baseUrl : `/${baseUrl}`;
+  const normalizedUrl = import_loader_utils4.path.resolve(normalizedBaseUrl, url);
+  return baseUrl.startsWith("/") ? normalizedUrl : normalizedUrl.slice(1);
+}
+function isRequestLikeUrl(url) {
+  return url.startsWith("http:") || url.startsWith("https:") || url.startsWith("file:") || url.startsWith("blob:");
+}
+function getCompositeImageFetch(options, context) {
+  var _a;
+  const fetchOption = options.fetch ?? ((_a = options.core) == null ? void 0 : _a.fetch);
+  if (context == null ? void 0 : context.fetch) {
+    return context.fetch;
+  }
+  if (typeof fetchOption === "function") {
+    return fetchOption;
+  }
+  if (fetchOption && typeof fetchOption === "object") {
+    return (url) => fetch(url, fetchOption);
+  }
+  return fetch;
+}
+function getCompositeImageSubloaderOptions(options) {
+  const core = options.core;
+  const rest = { ...options };
+  delete rest.baseUrl;
+  if (!(core == null ? void 0 : core.baseUrl)) {
+    return rest;
+  }
+  const restCore = { ...core };
+  delete restCore.baseUrl;
+  return {
+    ...rest,
+    core: restCore
+  };
+}
+function normalizeCompositeImageManifestOptions(options) {
+  var _a;
+  if (((_a = options.image) == null ? void 0 : _a.type) || typeof ImageBitmap === "undefined") {
+    return options;
+  }
+  return {
+    ...options,
+    image: {
+      ...options.image,
+      type: "imagebitmap"
+    }
+  };
+}
+function getCompositeImageMemberContext(resolvedUrl, response, context) {
+  const url = response.url || resolvedUrl;
+  const [urlWithoutQueryString, queryString = ""] = url.split("?");
+  return {
+    ...context,
+    url,
+    response,
+    filename: import_loader_utils4.path.filename(urlWithoutQueryString),
+    baseUrl: import_loader_utils4.path.dirname(urlWithoutQueryString),
+    queryString
+  };
+}
+function convertCompositeImageToTexture(shape, imageData) {
+  switch (shape) {
+    case "image-texture": {
+      const data = normalizeCompositeImageMember(imageData);
+      return {
+        shape: "texture",
+        type: "2d",
+        format: getCompositeTextureFormat(data),
+        data
+      };
+    }
+    case "image-texture-array": {
+      const data = imageData.map((layer) => normalizeCompositeImageMember(layer));
+      return {
+        shape: "texture",
+        type: "2d-array",
+        format: getCompositeTextureFormat(data[0]),
+        data
+      };
+    }
+    case "image-texture-cube": {
+      const data = IMAGE_TEXTURE_CUBE_FACES.map(({ face }) => normalizeCompositeImageMember(imageData[face]));
+      return {
+        shape: "texture",
+        type: "cube",
+        format: getCompositeTextureFormat(data[0]),
+        data
+      };
+    }
+    case "image-texture-cube-array": {
+      const data = imageData.map((layer) => IMAGE_TEXTURE_CUBE_FACES.map(({ face }) => normalizeCompositeImageMember(layer[face])));
+      return {
+        shape: "texture",
+        type: "cube-array",
+        format: getCompositeTextureFormat(data[0][0]),
+        data
+      };
+    }
+    default:
+      throw new Error(`Unsupported composite image shape ${shape}`);
+  }
+}
+function normalizeCompositeImageMember(imageData) {
+  if (Array.isArray(imageData)) {
+    if (imageData.length === 0) {
+      throw new Error("Composite image members must not be empty");
+    }
+    if (imageData.every(isTextureLevel)) {
+      return imageData;
+    }
+    if (imageData.every(import_images.isImage)) {
+      return imageData.map((image) => getTextureLevelFromImage(image));
+    }
+    if (imageData.every((entry) => Array.isArray(entry) && entry.every(isTextureLevel))) {
+      if (imageData.length !== 1) {
+        throw new Error("Composite image members must resolve to a single image or mip chain");
+      }
+      return imageData[0];
+    }
+  }
+  if (isTexture(imageData)) {
+    if (imageData.type !== "2d") {
+      throw new Error(`Composite image members must resolve to 2d textures, got ${imageData.type}`);
+    }
+    return imageData.data;
+  }
+  if (isTextureLevel(imageData)) {
+    return [imageData];
+  }
+  if ((0, import_images.isImage)(imageData)) {
+    return [getTextureLevelFromImage(imageData)];
+  }
+  throw new Error("Composite image members must resolve to an image, mip chain, or texture");
+}
+function getTextureLevelFromImage(image) {
+  const { width, height } = (0, import_images.getImageSize)(image);
+  return {
+    shape: "texture-level",
+    compressed: false,
+    width,
+    height,
+    imageBitmap: typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap ? image : void 0,
+    data: new Uint8Array(0),
+    textureFormat: "rgba8unorm"
+  };
+}
+function getCompositeTextureFormat(textureLevels) {
+  var _a;
+  return ((_a = textureLevels[0]) == null ? void 0 : _a.textureFormat) || "rgba8unorm";
+}
+function isTextureLevel(textureLevel) {
+  return Boolean(textureLevel && typeof textureLevel === "object" && "shape" in textureLevel && textureLevel.shape === "texture-level");
+}
+function isTexture(texture) {
+  return Boolean(texture && typeof texture === "object" && "shape" in texture && texture.shape === "texture");
+}
+function isAbsoluteCompositeImageUrl(url) {
+  return url.startsWith("data:") || url.startsWith("blob:") || url.startsWith("file:") || url.startsWith("http:") || url.startsWith("https:") || url.startsWith("/");
+}
+
+// dist/texture-loader.js
+var TextureLoader = {
+  dataType: null,
+  batchType: null,
+  id: "texture",
+  name: "Texture",
+  module: "textures",
+  version: VERSION,
+  extensions: [],
+  mimeTypes: [],
+  text: true,
+  worker: false,
+  testText: (text) => testCompositeImageManifestShape(text, "image-texture"),
+  options: {
+    image: {}
+  },
+  parse: async (arrayBuffer, options, context) => await parseCompositeImageManifest(new TextDecoder().decode(arrayBuffer), "image-texture", options, context),
+  parseText: async (text, options, context) => await parseCompositeImageManifest(text, "image-texture", options, context)
+};
+
+// dist/texture-array-loader.js
+var TextureArrayLoader = {
+  dataType: null,
+  batchType: null,
+  id: "texture-array",
+  name: "Texture Array",
+  module: "textures",
+  version: VERSION,
+  extensions: [],
+  mimeTypes: [],
+  text: true,
+  worker: false,
+  testText: (text) => testCompositeImageManifestShape(text, "image-texture-array"),
+  options: {
+    image: {}
+  },
+  parse: async (arrayBuffer, options, context) => await parseCompositeImageManifest(new TextDecoder().decode(arrayBuffer), "image-texture-array", options, context),
+  parseText: async (text, options, context) => await parseCompositeImageManifest(text, "image-texture-array", options, context)
+};
+
+// dist/texture-cube-loader.js
+var TextureCubeLoader = {
+  dataType: null,
+  batchType: null,
+  id: "texture-cube",
+  name: "Texture Cube",
+  module: "textures",
+  version: VERSION,
+  extensions: [],
+  mimeTypes: [],
+  text: true,
+  worker: false,
+  testText: (text) => testCompositeImageManifestShape(text, "image-texture-cube"),
+  options: {
+    image: {}
+  },
+  parse: async (arrayBuffer, options, context) => await parseCompositeImageManifest(new TextDecoder().decode(arrayBuffer), "image-texture-cube", options, context),
+  parseText: async (text, options, context) => await parseCompositeImageManifest(text, "image-texture-cube", options, context)
+};
+
+// dist/texture-cube-array-loader.js
+var TextureCubeArrayLoader = {
+  dataType: null,
+  batchType: null,
+  id: "texture-cube-array",
+  name: "Texture Cube Array",
+  module: "textures",
+  version: VERSION,
+  extensions: [],
+  mimeTypes: [],
+  text: true,
+  worker: false,
+  testText: (text) => testCompositeImageManifestShape(text, "image-texture-cube-array"),
+  options: {
+    image: {}
+  },
+  parse: async (arrayBuffer, options, context) => await parseCompositeImageManifest(new TextDecoder().decode(arrayBuffer), "image-texture-cube-array", options, context),
+  parseText: async (text, options, context) => await parseCompositeImageManifest(text, "image-texture-cube-array", options, context)
+};
+
+// dist/lib/parsers/crunch-module-loader.js
+var import_loader_utils5 = require("@loaders.gl/loader-utils");
+var import_worker_utils3 = require("@loaders.gl/worker-utils");
 var CRUNCH_EXTERNAL_LIBRARIES = {
   /** Crunch decoder library. It is used as dynamically imported script */
   DECODER: "crunch.js"
 };
 
 // dist/lib/encoders/encode-texture.js
-var import_worker_utils3 = require("@loaders.gl/worker-utils");
+var import_worker_utils4 = require("@loaders.gl/worker-utils");
 async function encodeImageURLToCompressedTextureURL(inputUrl, outputUrl, options) {
   const args = [
     // Note: our actual executable is `npx`, so `texture-compressor` is an argument
@@ -1461,7 +2398,7 @@ async function encodeImageURLToCompressedTextureURL(inputUrl, outputUrl, options
     "--output",
     outputUrl
   ];
-  const childProcess = new import_worker_utils3.ChildProcessProxy();
+  const childProcess = new import_worker_utils4.ChildProcessProxy();
   await childProcess.start({
     command: "npx",
     arguments: args,
@@ -1495,9 +2432,10 @@ var CompressedTextureWriter = {
 };
 
 // dist/lib/encoders/encode-ktx2-basis-texture.js
+var import_worker_utils5 = require("@loaders.gl/worker-utils");
 async function encodeKTX2BasisTexture(image, options = {}) {
   const { useSRGB = false, qualityLevel = 10, encodeUASTC = false, mipmaps = false } = (options == null ? void 0 : options["ktx2-basis-writer"]) || {};
-  const { BasisEncoder } = await loadBasisEncoderModule(options.core || {});
+  const { BasisEncoder } = await loadBasisEncoderModule((0, import_worker_utils5.extractLoadLibraryOptions)(options));
   const basisEncoder = new BasisEncoder();
   try {
     const basisFileData = new Uint8Array(image.width * image.height * 4);
@@ -1542,66 +2480,17 @@ var KTX2BasisWriter = {
 
 // dist/lib/texture-api/load-image.js
 var import_loader_utils6 = require("@loaders.gl/loader-utils");
-var import_images = require("@loaders.gl/images");
+var import_images2 = require("@loaders.gl/images");
 
 // dist/lib/texture-api/generate-url.js
-var import_loader_utils5 = require("@loaders.gl/loader-utils");
 function generateUrl(getUrl, options, urlOptions) {
-  let url = typeof getUrl === "function" ? getUrl({ ...options, ...urlOptions }) : getUrl;
-  const baseUrl = options.baseUrl;
-  if (baseUrl) {
-    url = baseUrl[baseUrl.length - 1] === "/" ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
-  }
-  return (0, import_loader_utils5.resolvePath)(url);
-}
-
-// dist/lib/texture-api/async-deep-map.js
-var isObject = (value) => value && typeof value === "object";
-async function asyncDeepMap(tree, func, options = {}) {
-  return await mapSubtree(tree, func, options);
-}
-async function mapSubtree(object, func, options) {
-  if (Array.isArray(object)) {
-    return await mapArray(object, func, options);
-  }
-  if (isObject(object)) {
-    return await mapObject(object, func, options);
-  }
-  const url = object;
-  return await func(url, options);
-}
-async function mapObject(object, func, options) {
-  const promises = [];
-  const values = {};
-  for (const key in object) {
-    const url = object[key];
-    const promise = mapSubtree(url, func, options).then((value) => {
-      values[key] = value;
-    });
-    promises.push(promise);
-  }
-  await Promise.all(promises);
-  return values;
-}
-async function mapArray(urlArray, func, options = {}) {
-  const promises = urlArray.map((url) => mapSubtree(url, func, options));
-  return await Promise.all(promises);
-}
-
-// dist/lib/texture-api/deep-load.js
-async function deepLoad(urlTree, load, options) {
-  return await asyncDeepMap(urlTree, (url) => shallowLoad(url, load, options));
-}
-async function shallowLoad(url, load, options) {
-  const response = await fetch(url, options.fetch);
-  const arrayBuffer = await response.arrayBuffer();
-  return await load(arrayBuffer, options);
+  return typeof getUrl === "function" ? getUrl({ ...options, ...urlOptions }) : getUrl;
 }
 
 // dist/lib/texture-api/load-image.js
 async function loadImageTexture(getUrl, options = {}) {
   const imageUrls = await getImageUrls(getUrl, options);
-  return await deepLoad(imageUrls, import_images.ImageLoader.parse, options);
+  return await loadCompositeImageUrlTree(imageUrls, normalizeCompositeImageOptions(options));
 }
 async function getImageUrls(getUrl, options, urlOptions = {}) {
   const mipLevels = options && options.image && options.image.mipLevels || 0;
@@ -1609,10 +2498,11 @@ async function getImageUrls(getUrl, options, urlOptions = {}) {
 }
 async function getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) {
   const urls = [];
+  const normalizedOptions = normalizeCompositeImageOptions(options);
   if (mipLevels === "auto") {
     const url = generateUrl(getUrl, options, { ...urlOptions, lod: 0 });
-    const image = await shallowLoad(url, import_images.ImageLoader.parse, options);
-    const { width, height } = (0, import_images.getImageSize)(image);
+    const image = await loadCompositeImageMember(url, normalizedOptions);
+    const { width, height } = (0, import_images2.getImageSize)(image);
     mipLevels = getMipLevels({ width, height });
     urls.push(url);
   }
@@ -1628,10 +2518,9 @@ function getMipLevels(size) {
 }
 
 // dist/lib/texture-api/load-image-array.js
-var import_images2 = require("@loaders.gl/images");
 async function loadImageTextureArray(count, getUrl, options = {}) {
   const imageUrls = await getImageArrayUrls(count, getUrl, options);
-  return await deepLoad(imageUrls, import_images2.ImageLoader.parse, options);
+  return await loadCompositeImageUrlTree(imageUrls, normalizeCompositeImageOptions(options));
 }
 async function getImageArrayUrls(count, getUrl, options = {}) {
   const promises = [];
@@ -1643,27 +2532,12 @@ async function getImageArrayUrls(count, getUrl, options = {}) {
 }
 
 // dist/lib/texture-api/load-image-cube.js
-var import_images3 = require("@loaders.gl/images");
-var GL_TEXTURE_CUBE_MAP_POSITIVE_X = 34069;
-var GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 34070;
-var GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 34071;
-var GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 34072;
-var GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 34073;
-var GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 34074;
-var CUBE_FACES = [
-  { face: GL_TEXTURE_CUBE_MAP_POSITIVE_X, direction: "right", axis: "x", sign: "positive" },
-  { face: GL_TEXTURE_CUBE_MAP_NEGATIVE_X, direction: "left", axis: "x", sign: "negative" },
-  { face: GL_TEXTURE_CUBE_MAP_POSITIVE_Y, direction: "top", axis: "y", sign: "positive" },
-  { face: GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, direction: "bottom", axis: "y", sign: "negative" },
-  { face: GL_TEXTURE_CUBE_MAP_POSITIVE_Z, direction: "front", axis: "z", sign: "positive" },
-  { face: GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, direction: "back", axis: "z", sign: "negative" }
-];
 async function getImageCubeUrls(getUrl, options) {
   const urls = {};
   const promises = [];
   let index = 0;
-  for (let i = 0; i < CUBE_FACES.length; ++i) {
-    const face = CUBE_FACES[index];
+  for (let i = 0; i < IMAGE_TEXTURE_CUBE_FACES.length; ++i) {
+    const face = IMAGE_TEXTURE_CUBE_FACES[index];
     const promise = getImageUrls(getUrl, options, { ...face, index: index++ }).then((url) => {
       urls[face.face] = url;
     });
@@ -1674,7 +2548,7 @@ async function getImageCubeUrls(getUrl, options) {
 }
 async function loadImageTextureCube(getUrl, options = {}) {
   const urls = await getImageCubeUrls(getUrl, options);
-  return await deepLoad(urls, import_images3.ImageLoader.parse, options);
+  return await loadCompositeImageUrlTree(urls, normalizeCompositeImageOptions(options));
 }
 
 // dist/index.js