@loaders.gl/textures 3.1.7 → 3.2.0-alpha.2

package/dist/ktx2-basis-writer-nodejs.d.ts

@@ -0,0 +1,3 @@
+import '@loaders.gl/polyfills';
+export { KTX2BasisWriter as KTX2BasisWriterNodeJS } from './ktx2-basis-writer';
+//# sourceMappingURL=ktx2-basis-writer-nodejs.d.ts.map

package/dist/ktx2-basis-writer-nodejs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ktx2-basis-writer-nodejs.d.ts","sourceRoot":"","sources":["../src/ktx2-basis-writer-nodejs.ts"],"names":[],"mappings":"AACA,OAAO,uBAAuB,CAAC;AAE/B,OAAO,EAAC,eAAe,IAAI,qBAAqB,EAAC,MAAM,qBAAqB,CAAC"}

package/dist/ktx2-basis-writer-nodejs.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KTX2BasisWriterNodeJS = void 0;
+// Polyfills increases the bundle size significantly. Use it for NodeJS worker only
+require("@loaders.gl/polyfills");
+var ktx2_basis_writer_1 = require("./ktx2-basis-writer");
+Object.defineProperty(exports, "KTX2BasisWriterNodeJS", { enumerable: true, get: function () { return ktx2_basis_writer_1.KTX2BasisWriter; } });

package/dist/ktx2-basis-writer-worker.js

@@ -0,0 +1,343 @@
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __reExport = (target, module, desc) => {
+    if (module && typeof module === "object" || typeof module === "function") {
+      for (let key of __getOwnPropNames(module))
+        if (!__hasOwnProp.call(target, key) && key !== "default")
+          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+    }
+    return target;
+  };
+  var __toModule = (module) => {
+    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+  };
+
+  // (disabled):../worker-utils/src/lib/node/require-utils.node
+  var require_require_utils = __commonJS({
+    "(disabled):../worker-utils/src/lib/node/require-utils.node"() {
+    }
+  });
+
+  // ../worker-utils/src/lib/env-utils/version.ts
+  var VERSION = true ? "3.2.0-alpha.2" : DEFAULT_VERSION;
+  if (false) {
+    console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+  }
+
+  // ../worker-utils/src/lib/env-utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loaders.gl assertion failed.");
+    }
+  }
+
+  // ../worker-utils/src/lib/env-utils/globals.ts
+  var globals = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
+  };
+  var self_ = globals.self || globals.window || globals.global || {};
+  var window_ = globals.window || globals.self || globals.global || {};
+  var global_ = globals.global || globals.self || globals.window || {};
+  var document_ = globals.document || {};
+  var isBrowser = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
+  var isWorker = typeof importScripts === "function";
+  var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion = matches && parseFloat(matches[1]) || 0;
+
+  // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
+  function getTransferList(object, recursive = true, transfers) {
+    const transfersSet = transfers || new Set();
+    if (!object) {
+    } else if (isTransferable(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList(object[key], recursive, transfersSet);
+      }
+    }
+    return transfers === void 0 ? Array.from(transfersSet) : [];
+  }
+  function isTransferable(object) {
+    if (!object) {
+      return false;
+    }
+    if (object instanceof ArrayBuffer) {
+      return true;
+    }
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
+    }
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
+    }
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
+    }
+    return false;
+  }
+
+  // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  function getParentPort() {
+    let parentPort;
+    try {
+      eval("globalThis.parentPort = require('worker_threads').parentPort");
+      parentPort = globalThis.parentPort;
+    } catch {
+    }
+    return parentPort;
+  }
+  var onMessageWrapperMap = new Map();
+  var WorkerBody = class {
+    static inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(getParentPort());
+    }
+    static set onmessage(onMessage) {
+      function handleMessage(message) {
+        const parentPort3 = getParentPort();
+        const { type, payload } = parentPort3 ? message : message.data;
+        onMessage(type, payload);
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.on("message", handleMessage);
+        parentPort2.on("exit", () => console.debug("Node worker closing"));
+      } else {
+        globalThis.onmessage = handleMessage;
+      }
+    }
+    static addEventListener(onMessage) {
+      let onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      if (!onMessageWrapper) {
+        onMessageWrapper = (message) => {
+          if (!isKnownMessage(message)) {
+            return;
+          }
+          const parentPort3 = getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
+          onMessage(type, payload);
+        };
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
+    }
+    static removeEventListener(onMessage) {
+      const onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      onMessageWrapperMap.delete(onMessage);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
+    }
+    static postMessage(type, payload) {
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
+      }
+    }
+  };
+  function isKnownMessage(message) {
+    const { type, data } = message;
+    return type === "message" && data && typeof data.source === "string" && data.source.startsWith("loaders.gl");
+  }
+
+  // ../worker-utils/src/lib/library-utils/library-utils.ts
+  var node = __toModule(require_require_utils());
+  var LATEST = "beta";
+  var VERSION2 = typeof VERSION !== "undefined" ? VERSION : LATEST;
+  var loadLibraryPromises = {};
+  async function loadLibrary(libraryUrl, moduleName = null, options = {}) {
+    if (moduleName) {
+      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options);
+    }
+    loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
+    return await loadLibraryPromises[libraryUrl];
+  }
+  function getLibraryUrl(library, moduleName, options) {
+    if (library.startsWith("http")) {
+      return library;
+    }
+    const modules = options.modules || {};
+    if (modules[library]) {
+      return modules[library];
+    }
+    if (!isBrowser) {
+      return `modules/${moduleName}/dist/libs/${library}`;
+    }
+    if (options.CDN) {
+      assert(options.CDN.startsWith("http"));
+      return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${library}`;
+    }
+    if (isWorker) {
+      return `../src/libs/${library}`;
+    }
+    return `modules/${moduleName}/src/libs/${library}`;
+  }
+  async function loadLibraryFromFile(libraryUrl) {
+    if (libraryUrl.endsWith("wasm")) {
+      const response2 = await fetch(libraryUrl);
+      return await response2.arrayBuffer();
+    }
+    if (!isBrowser) {
+      try {
+        return node && node.requireFromFile && await node.requireFromFile(libraryUrl);
+      } catch {
+        return null;
+      }
+    }
+    if (isWorker) {
+      return importScripts(libraryUrl);
+    }
+    const response = await fetch(libraryUrl);
+    const scriptSource = await response.text();
+    return loadLibraryFromString(scriptSource, libraryUrl);
+  }
+  function loadLibraryFromString(scriptSource, id) {
+    if (!isBrowser) {
+      return node.requireFromString && node.requireFromString(scriptSource, id);
+    }
+    if (isWorker) {
+      eval.call(global_, scriptSource);
+      return null;
+    }
+    const script = document.createElement("script");
+    script.id = id;
+    try {
+      script.appendChild(document.createTextNode(scriptSource));
+    } catch (e) {
+      script.text = scriptSource;
+    }
+    document.body.appendChild(script);
+    return null;
+  }
+
+  // src/lib/utils/version.ts
+  var VERSION3 = true ? "3.2.0-alpha.2" : "beta";
+
+  // src/lib/parsers/basis-module-loader.ts
+  var VERSION4 = true ? "3.2.0-alpha.2" : "beta";
+  var BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION4}/dist/libs/basis_encoder.wasm`;
+  var BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION4}/dist/libs/basis_encoder.js`;
+  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_CDN_ENCODER_JS, "textures", options),
+      await loadLibrary(BASIS_CDN_ENCODER_WASM, "textures", options)
+    ]);
+    BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
+    return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
+  }
+  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve) => {
+      BasisEncoderModule(options).then((module) => {
+        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
+        initializeBasis();
+        resolve({ BasisFile, KTX2File, BasisEncoder });
+      });
+    });
+  }
+
+  // src/lib/encoders/encode-ktx2-basis-texture.ts
+  async function encodeKTX2BasisTexture(image, options = {}) {
+    const { useSRGB = false, qualityLevel = 10, encodeUASTC = false, mipmaps = false } = options;
+    const { BasisEncoder } = await loadBasisEncoderModule(options);
+    const basisEncoder = new BasisEncoder();
+    try {
+      const basisFileData = new Uint8Array(image.width * image.height * 4);
+      basisEncoder.setCreateKTX2File(true);
+      basisEncoder.setKTX2UASTCSupercompression(true);
+      basisEncoder.setKTX2SRGBTransferFunc(true);
+      basisEncoder.setSliceSourceImage(0, image.data, image.width, image.height, false);
+      basisEncoder.setPerceptual(useSRGB);
+      basisEncoder.setMipSRGB(useSRGB);
+      basisEncoder.setQualityLevel(qualityLevel);
+      basisEncoder.setUASTC(encodeUASTC);
+      basisEncoder.setMipGen(mipmaps);
+      const numOutputBytes = basisEncoder.encode(basisFileData);
+      const actualKTX2FileData = basisFileData.subarray(0, numOutputBytes).buffer;
+      return actualKTX2FileData;
+    } catch (error) {
+      console.error("Basis Universal Supercompressed GPU Texture encoder Error: ", error);
+      throw error;
+    } finally {
+      basisEncoder.delete();
+    }
+  }
+
+  // src/ktx2-basis-writer.ts
+  var KTX2BasisWriter = {
+    name: "Basis Universal Supercompressed GPU Texture",
+    id: "ktx2-basis-writer",
+    module: "textures",
+    version: VERSION3,
+    extensions: ["ktx2"],
+    options: {
+      useSRGB: false,
+      qualityLevel: 10,
+      encodeUASTC: false,
+      mipmaps: false
+    },
+    encode: encodeKTX2BasisTexture
+  };
+
+  // src/workers/ktx2-basis-writer-worker.ts
+  (() => {
+    if (!WorkerBody.inWorkerThread()) {
+      return;
+    }
+    WorkerBody.onmessage = async (type, payload) => {
+      switch (type) {
+        case "process":
+          try {
+            const { input, options } = payload;
+            const result = await KTX2BasisWriter.encode(input, options);
+            WorkerBody.postMessage("done", { result });
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "";
+            WorkerBody.postMessage("error", { error: message });
+          }
+          break;
+        default:
+      }
+    };
+  })();
+})();

package/dist/{ktx2-basis-universal-texture-writer.d.ts → ktx2-basis-writer.d.ts}

@@ -4,7 +4,7 @@ import { encodeKTX2BasisTexture } from './lib/encoders/encode-ktx2-basis-texture
  *  Basis Universal Supercompressed GPU Texture.
  *  Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.8/textureSetDefinitionFormat.cmn.md
  */
-export declare const KTX2BasisUniversalTextureWriter: {
+export declare const KTX2BasisWriter: {
     name: string;
     id: string;
     module: string;
@@ -19,4 +19,4 @@ export declare const KTX2BasisUniversalTextureWriter: {
     encode: typeof encodeKTX2BasisTexture;
 };
 export declare const _TypecheckKTX2TextureWriter: Writer;
-//# sourceMappingURL=ktx2-basis-universal-texture-writer.d.ts.map
+//# sourceMappingURL=ktx2-basis-writer.d.ts.map

package/dist/ktx2-basis-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ktx2-basis-writer.d.ts","sourceRoot":"","sources":["../src/ktx2-basis-writer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAErD,OAAO,EAAC,sBAAsB,EAAC,MAAM,0CAA0C,CAAC;AAEhF;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;CAe3B,CAAC;AAGF,eAAO,MAAM,2BAA2B,EAAE,MAAwB,CAAC"}

package/dist/{ktx2-basis-universal-texture-writer.js → ktx2-basis-writer.js}

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._TypecheckKTX2TextureWriter = exports.KTX2BasisUniversalTextureWriter = void 0;
+exports._TypecheckKTX2TextureWriter = exports.KTX2BasisWriter = void 0;
 const version_1 = require("./lib/utils/version");
 const encode_ktx2_basis_texture_1 = require("./lib/encoders/encode-ktx2-basis-texture");
 /**
  *  Basis Universal Supercompressed GPU Texture.
  *  Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.8/textureSetDefinitionFormat.cmn.md
  */
-exports.KTX2BasisUniversalTextureWriter = {
+exports.KTX2BasisWriter = {
     name: 'Basis Universal Supercompressed GPU Texture',
-    id: 'ktx2-basis-supercompressed-texture',
+    id: 'ktx2-basis-writer',
     module: 'textures',
     version: version_1.VERSION,
     extensions: ['ktx2'],
@@ -22,4 +22,4 @@ exports.KTX2BasisUniversalTextureWriter = {
     encode: encode_ktx2_basis_texture_1.encodeKTX2BasisTexture
 };
 // TYPE TESTS - TODO find a better way than exporting junk
-exports._TypecheckKTX2TextureWriter = exports.KTX2BasisUniversalTextureWriter;
+exports._TypecheckKTX2TextureWriter = exports.KTX2BasisWriter;

package/dist/lib/encoders/encode-texture.d.ts

@@ -1,4 +1,3 @@
-export declare function encodeImageURLToCompressedTextureURL(inputUrl: string, outputUrl: string, options?: {
-    cwd?: string;
-}): Promise<string>;
+import { CompressedTextureWriterOptions } from '../../compressed-texture-writer';
+export declare function encodeImageURLToCompressedTextureURL(inputUrl: string, outputUrl: string, options?: CompressedTextureWriterOptions): Promise<string>;
 //# sourceMappingURL=encode-texture.d.ts.map

package/dist/lib/encoders/encode-texture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode-texture.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-texture.ts"],"names":[],"mappings":"AAKA,wBAAsB,oCAAoC,CACxD,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAC,GACvB,OAAO,CAAC,MAAM,CAAC,CAkBjB"}
+{"version":3,"file":"encode-texture.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-texture.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,8BAA8B,EAAC,MAAM,iCAAiC,CAAC;AAK/E,wBAAsB,oCAAoC,CACxD,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,8BAA8B,GACvC,OAAO,CAAC,MAAM,CAAC,CAkBjB"}

package/dist/lib/parsers/basis-module-loader.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadBasisEncoderModule = exports.loadBasisTrascoderModule = void 0;
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'beta';
 // @ts-nocheck
 const worker_utils_1 = require("@loaders.gl/worker-utils");
 const BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION}/dist/libs/basis_encoder.wasm`;

package/dist/lib/parsers/parse-basis.d.ts

@@ -1,16 +1,18 @@
+import type { TextureLevel } from '@loaders.gl/schema';
+export declare type BasisFormat = 'etc1' | 'etc2' | 'bc1' | 'bc3' | 'bc4' | 'bc5' | 'bc7-m6-opaque-only' | 'bc7-m5' | 'pvrtc1-4-rgb' | 'pvrtc1-4-rgba' | 'astc-4x4' | 'atc-rgb' | 'atc-rgba-interpolated-alpha' | 'rgba32' | 'rgb565' | 'bgr565' | 'rgba4444';
 /**
  * parse data with a Binomial Basis_Universal module
- * @param {ArrayBuffer} data
- * @param {*} options
+ * @param data
+ * @param options
  * @returns compressed texture data
  */
-export default function parseBasis(data: any, options: any): Promise<any[] | null>;
+export default function parseBasis(data: ArrayBuffer, options: any): Promise<TextureLevel[][]>;
 /**
  * Select transcode format from the list of supported formats
  * @returns key for OutputFormat map
  */
-export declare function selectSupportedBasisFormat(): "etc1" | "etc2" | "astc-4x4" | "rgb565" | {
-    alpha: string;
-    noAlpha: string;
+export declare function selectSupportedBasisFormat(): BasisFormat | {
+    alpha: BasisFormat;
+    noAlpha: BasisFormat;
 };
 //# sourceMappingURL=parse-basis.d.ts.map

package/dist/lib/parsers/parse-basis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-basis.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-basis.ts"],"names":[],"mappings":"AAiDA;;;;;GAKG;AACH,wBAA8B,UAAU,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,yBAwBrD;AA8KD;;;GAGG;AACH,wBAAgB,0BAA0B;;;EAoBzC"}
+{"version":3,"file":"parse-basis.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-basis.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAMrD,oBAAY,WAAW,GACnB,MAAM,GACN,MAAM,GACN,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,oBAAoB,GACpB,QAAQ,GACR,cAAc,GACd,eAAe,GACf,UAAU,GACV,SAAS,GACT,6BAA6B,GAC7B,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,UAAU,CAAC;AAoDf;;;;;GAKG;AACH,wBAA8B,UAAU,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,KAAA,GAAG,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAwB9F;AA8KD;;;GAGG;AACH,wBAAgB,0BAA0B,IACtC,WAAW,GACX;IACE,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,WAAW,CAAC;CACtB,CAoBJ"}

package/dist/lib/parsers/parse-basis.js

@@ -50,8 +50,8 @@ const OutputFormat = {
 };
 /**
  * parse data with a Binomial Basis_Universal module
- * @param {ArrayBuffer} data
- * @param {*} options
+ * @param data
+ * @param options
  * @returns compressed texture data
  */
 async function parseBasis(data, options) {
@@ -82,16 +82,16 @@ async function parseBasis(data, options) {
 exports.default = parseBasis;
 /**
  * Parse *.basis file data
- * @param {*} BasisFile - initialized transcoder module
- * @param {*} data
- * @param {*} options
+ * @param BasisFile - initialized transcoder module
+ * @param data
+ * @param options
  * @returns compressed texture data
  */
 function parseBasisFile(BasisFile, data, options) {
     const basisFile = new BasisFile(new Uint8Array(data));
     try {
         if (!basisFile.startTranscoding()) {
-            return null;
+            throw new Error('Failed to start basis transcoding');
         }
         const imageCount = basisFile.getNumImages();
         const images = [];
@@ -112,10 +112,10 @@ function parseBasisFile(BasisFile, data, options) {
 }
 /**
  * Parse the particular level image of a basis file
- * @param {*} basisFile
- * @param {*} imageIndex
- * @param {*} levelIndex
- * @param {*} options
+ * @param basisFile
+ * @param imageIndex
+ * @param levelIndex
+ * @param options
  * @returns compressed texture data
  */
 function transcodeImage(basisFile, imageIndex, levelIndex, options) {
@@ -128,7 +128,7 @@ function transcodeImage(basisFile, imageIndex, levelIndex, options) {
     const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
     const decodedData = new Uint8Array(decodedSize);
     if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
-        return null;
+        throw new Error('failed to start Basis transcoding');
     }
     return {
         // standard loaders.gl image category payload
@@ -136,24 +136,24 @@ function transcodeImage(basisFile, imageIndex, levelIndex, options) {
         height,
         data: decodedData,
         compressed,
+        format,
         // Additional fields
         // Add levelSize field.
-        hasAlpha,
-        format
+        hasAlpha
     };
 }
 /**
  * Parse *.ktx2 file data
- * @param {*} KTX2File
- * @param {*} data
- * @param {*} options
+ * @param KTX2File
+ * @param data
+ * @param options
  * @returns compressed texture data
  */
 function parseKTX2File(KTX2File, data, options) {
     const ktx2File = new KTX2File(new Uint8Array(data));
     try {
         if (!ktx2File.startTranscoding()) {
-            return null;
+            throw new Error('failed to start KTX2 transcoding');
         }
         const levelsCount = ktx2File.getLevels();
         const levels = [];
@@ -161,7 +161,7 @@ function parseKTX2File(KTX2File, data, options) {
             levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
             break; // texture app can only show one level for some reason
         }
-        return levels;
+        return [levels];
     }
     finally {
         ktx2File.close();
@@ -170,9 +170,9 @@ function parseKTX2File(KTX2File, data, options) {
 }
 /**
  * Parse the particular level image of a ktx2 file
- * @param {*} ktx2File
- * @param {*} levelIndex
- * @param {*} options
+ * @param ktx2File
+ * @param levelIndex
+ * @param options
  * @returns
  */
 function transcodeKTX2Image(ktx2File, levelIndex, options) {
@@ -182,7 +182,7 @@ function transcodeKTX2Image(ktx2File, levelIndex, options) {
     const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0 /* layerIndex */, 0 /* faceIndex */, basisFormat);
     const decodedData = new Uint8Array(decodedSize);
     if (!ktx2File.transcodeImage(decodedData, levelIndex, 0 /* layerIndex */, 0 /* faceIndex */, basisFormat, 0, -1 /* channel0 */, -1 /* channel1 */)) {
-        return null;
+        throw new Error('Failed to transcode KTX2 image');
     }
     return {
         // standard loaders.gl image category payload
@@ -192,14 +192,14 @@ function transcodeKTX2Image(ktx2File, levelIndex, options) {
         compressed,
         // Additional fields
         // Add levelSize field.
-        alphaFlag,
+        hasAlpha: alphaFlag,
         format
     };
 }
 /**
  * Get BasisFormat by loader format option
- * @param {*} options
- * @param {*} hasAlpha
+ * @param options
+ * @param hasAlpha
  * @returns BasisFormat data
  */
 function getBasisOptions(options, hasAlpha) {

package/dist/lib/parsers/parse-compressed-texture.d.ts

@@ -1,4 +1,4 @@
-import type { TextureLevel } from '../../types';
+import type { TextureLevel } from '@loaders.gl/schema';
 /**
  * Deduces format and parses compressed texture loaded in ArrayBuffer
  * @param data - binary data of compressed texture

package/dist/lib/parsers/parse-compressed-texture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-compressed-texture.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-compressed-texture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAK9C;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,WAAW,GAAG,YAAY,EAAE,CAaxE"}
+{"version":3,"file":"parse-compressed-texture.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-compressed-texture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAKrD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,WAAW,GAAG,YAAY,EAAE,CAaxE"}

package/dist/lib/parsers/parse-crunch.d.ts

@@ -1,4 +1,4 @@
-import type { TextureLevel } from '../../types';
+import type { TextureLevel } from '@loaders.gl/schema';
 /**
  * Parse texture data as "CRN" format.
  * Function is "async" as emscriptified decoder module is loaded asyncronously

package/dist/lib/parsers/parse-crunch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-crunch.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-crunch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAqC9C;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,IAAI,KAAA,EAAE,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAmD7E"}
+{"version":3,"file":"parse-crunch.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-crunch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAsCrD;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,IAAI,KAAA,EAAE,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAmD7E"}

package/dist/lib/parsers/parse-crunch.js

@@ -15,19 +15,20 @@ const CRN_FORMAT = {
     cCRNFmtDXT5: 2
     // Crunch supports more formats than this.
 };
-// Mapping of Crunch formats to DXT formats.
-const DXT_FORMAT_MAP = {};
-DXT_FORMAT_MAP[CRN_FORMAT.cCRNFmtDXT1] = {
-    pixelFormat: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
-    sizeFunction: parse_dds_1.getDxt1LevelSize
-};
-DXT_FORMAT_MAP[CRN_FORMAT.cCRNFmtDXT3] = {
-    pixelFormat: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
-    sizeFunction: parse_dds_1.getDxtXLevelSize
-};
-DXT_FORMAT_MAP[CRN_FORMAT.cCRNFmtDXT5] = {
-    pixelFormat: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-    sizeFunction: parse_dds_1.getDxtXLevelSize
+/** Mapping of Crunch formats to DXT formats. */
+const DXT_FORMAT_MAP = {
+    [CRN_FORMAT.cCRNFmtDXT1]: {
+        pixelFormat: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
+        sizeFunction: parse_dds_1.getDxt1LevelSize
+    },
+    [CRN_FORMAT.cCRNFmtDXT3]: {
+        pixelFormat: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+        sizeFunction: parse_dds_1.getDxtXLevelSize
+    },
+    [CRN_FORMAT.cCRNFmtDXT5]: {
+        pixelFormat: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+        sizeFunction: parse_dds_1.getDxtXLevelSize
+    }
 };
 let cachedDstSize = 0;
 let dst;

package/dist/lib/parsers/parse-dds.d.ts

@@ -1,4 +1,4 @@
-import type { TextureLevel } from '../../types';
+import type { TextureLevel } from '@loaders.gl/schema';
 /**
  * Check if data is in "DDS" format by its magic number
  * @param data - binary data of compressed texture