@loaders.gl/textures 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/lib/gl-extensions.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GL_EXTENSIONS_CONSTANTS = void 0;
+/* eslint-disable camelcase */
+exports.GL_EXTENSIONS_CONSTANTS = {
+    // WEBGL_compressed_texture_s3tc
+    COMPRESSED_RGB_S3TC_DXT1_EXT: 0x83f0,
+    COMPRESSED_RGBA_S3TC_DXT1_EXT: 0x83f1,
+    COMPRESSED_RGBA_S3TC_DXT3_EXT: 0x83f2,
+    COMPRESSED_RGBA_S3TC_DXT5_EXT: 0x83f3,
+    // WEBGL_compressed_texture_es3
+    COMPRESSED_R11_EAC: 0x9270,
+    COMPRESSED_SIGNED_R11_EAC: 0x9271,
+    COMPRESSED_RG11_EAC: 0x9272,
+    COMPRESSED_SIGNED_RG11_EAC: 0x9273,
+    COMPRESSED_RGB8_ETC2: 0x9274,
+    COMPRESSED_RGBA8_ETC2_EAC: 0x9275,
+    COMPRESSED_SRGB8_ETC2: 0x9276,
+    COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 0x9277,
+    COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 0x9278,
+    COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 0x9279,
+    // WEBGL_compressed_texture_pvrtc
+    COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 0x8c00,
+    COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 0x8c02,
+    COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 0x8c01,
+    COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 0x8c03,
+    // WEBGL_compressed_texture_etc1
+    COMPRESSED_RGB_ETC1_WEBGL: 0x8d64,
+    // WEBGL_compressed_texture_atc
+    COMPRESSED_RGB_ATC_WEBGL: 0x8c92,
+    COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 0x8c93,
+    COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 0x87ee,
+    // WEBGL_compressed_texture_astc
+    COMPRESSED_RGBA_ASTC_4X4_KHR: 0x93b0,
+    COMPRESSED_RGBA_ASTC_5X4_KHR: 0x93b1,
+    COMPRESSED_RGBA_ASTC_5X5_KHR: 0x93b2,
+    COMPRESSED_RGBA_ASTC_6X5_KHR: 0x93b3,
+    COMPRESSED_RGBA_ASTC_6X6_KHR: 0x93b4,
+    COMPRESSED_RGBA_ASTC_8X5_KHR: 0x93b5,
+    COMPRESSED_RGBA_ASTC_8X6_KHR: 0x93b6,
+    COMPRESSED_RGBA_ASTC_8X8_KHR: 0x93b7,
+    COMPRESSED_RGBA_ASTC_10X5_KHR: 0x93b8,
+    COMPRESSED_RGBA_ASTC_10X6_KHR: 0x93b9,
+    COMPRESSED_RGBA_ASTC_10X8_KHR: 0x93ba,
+    COMPRESSED_RGBA_ASTC_10X10_KHR: 0x93bb,
+    COMPRESSED_RGBA_ASTC_12X10_KHR: 0x93bc,
+    COMPRESSED_RGBA_ASTC_12X12_KHR: 0x93bd,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR: 0x93d0,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR: 0x93d1,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR: 0x93d2,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR: 0x93d3,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR: 0x93d4,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR: 0x93d5,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR: 0x93d6,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR: 0x93d7,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR: 0x93d8,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR: 0x93d9,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR: 0x93da,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR: 0x93db,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR: 0x93dc,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR: 0x93dd,
+    // EXT_texture_compression_rgtc
+    COMPRESSED_RED_RGTC1_EXT: 0x8dbb,
+    COMPRESSED_SIGNED_RED_RGTC1_EXT: 0x8dbc,
+    COMPRESSED_RED_GREEN_RGTC2_EXT: 0x8dbd,
+    COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 0x8dbe,
+    // WEBGL_compressed_texture_s3tc_srgb
+    COMPRESSED_SRGB_S3TC_DXT1_EXT: 0x8c4c,
+    COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 0x8c4d,
+    COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 0x8c4e,
+    COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 0x8c4f
+};

package/dist/lib/parsers/basis-module-loader.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Loads wasm transcoder module
+ * @param options
+ * @returns {BasisFile} promise
+ */
+export declare function loadBasisTrascoderModule(options: any): Promise<any>;
+/**
+ * Loads wasm encoder module
+ * @param options
+ * @returns {BasisFile, KTX2File} promise
+ */
+export declare function loadBasisEncoderModule(options: any): Promise<any>;
+//# sourceMappingURL=basis-module-loader.d.ts.map

package/dist/lib/parsers/basis-module-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basis-module-loader.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/basis-module-loader.ts"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,wBAAsB,wBAAwB,CAAC,OAAO,KAAA,gBAQrD;AA+CD;;;;GAIG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,KAAA,gBAQnD"}

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

@@ -0,0 +1,114 @@
+"use strict";
+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__ : '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`;
+const BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION}/dist/libs/basis_encoder.js`;
+let loadBasisTranscoderPromise;
+/**
+ * Loads wasm transcoder module
+ * @param options
+ * @returns {BasisFile} promise
+ */
+async function loadBasisTrascoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basis) {
+        return modules.basis;
+    }
+    loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTrascoder(options);
+    return await loadBasisTranscoderPromise;
+}
+exports.loadBasisTrascoderModule = loadBasisTrascoderModule;
+/**
+ * Loads wasm transcoder module
+ * @param options
+ * @returns {BasisFile} promise
+ */
+async function loadBasisTrascoder(options) {
+    let BASIS = null;
+    let wasmBinary = null;
+    [BASIS, wasmBinary] = await Promise.all([
+        await (0, worker_utils_1.loadLibrary)('basis_transcoder.js', 'textures', options),
+        await (0, worker_utils_1.loadLibrary)('basis_transcoder.wasm', 'textures', options)
+    ]);
+    // Depends on how import happened...
+    // @ts-ignore TS2339: Property does not exist on type
+    BASIS = BASIS || globalThis.BASIS;
+    return await initializeBasisTrascoderModule(BASIS, wasmBinary);
+}
+/**
+ * Initialize wasm transcoder module
+ * @param BasisModule - js part of the module
+ * @param wasmBinary - wasm part of the module
+ * @returns {BasisFile} promise
+ */
+function initializeBasisTrascoderModule(BasisModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+        options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve) => {
+        // if you try to return BasisModule the browser crashes!
+        BasisModule(options).then((module) => {
+            const { BasisFile, initializeBasis } = module;
+            initializeBasis();
+            resolve({ BasisFile });
+        });
+    });
+}
+let loadBasisEncoderPromise;
+/**
+ * Loads wasm encoder module
+ * @param options
+ * @returns {BasisFile, KTX2File} promise
+ */
+async function loadBasisEncoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basisEncoder) {
+        return modules.basisEncoder;
+    }
+    loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
+    return await loadBasisEncoderPromise;
+}
+exports.loadBasisEncoderModule = loadBasisEncoderModule;
+/**
+ * Loads wasm encoder module
+ * @param options
+ * @returns {BasisFile, KTX2File} promise
+ */
+async function loadBasisEncoder(options) {
+    let BASIS_ENCODER = null;
+    let wasmBinary = null;
+    [BASIS_ENCODER, wasmBinary] = await Promise.all([
+        await (0, worker_utils_1.loadLibrary)(BASIS_CDN_ENCODER_JS, 'textures', options),
+        await (0, worker_utils_1.loadLibrary)(BASIS_CDN_ENCODER_WASM, 'textures', options)
+    ]);
+    // Depends on how import happened...
+    // @ts-ignore TS2339: Property does not exist on type
+    BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
+    return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
+}
+/**
+ * Initialize wasm transcoder module
+ * @param BasisEncoderModule - js part of the module
+ * @param wasmBinary - wasm part of the module
+ * @returns {BasisFile, KTX2File} promise
+ */
+function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+        options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve) => {
+        // if you try to return BasisModule the browser crashes!
+        BasisEncoderModule(options).then((module) => {
+            const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
+            initializeBasis();
+            resolve({ BasisFile, KTX2File, BasisEncoder });
+        });
+    });
+}

package/dist/lib/parsers/crunch-module-loader.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Load crunch decoder module
+ * @param options - loader options
+ * @returns Promise of module object
+ */
+export declare function loadCrunchModule(options: any): Promise<any>;
+//# sourceMappingURL=crunch-module-loader.d.ts.map

package/dist/lib/parsers/crunch-module-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crunch-module-loader.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/crunch-module-loader.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC,CAO5D"}

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCrunchModule = void 0;
+// @ts-nocheck
+const worker_utils_1 = require("@loaders.gl/worker-utils");
+/**
+ * Load crunch decoder module
+ * @param options - loader options
+ * @returns Promise of module object
+ */
+async function loadCrunchModule(options) {
+    const modules = options.modules || {};
+    if (modules.crunch) {
+        return modules.crunch;
+    }
+    return loadCrunch(options);
+}
+exports.loadCrunchModule = loadCrunchModule;
+let crunchModule;
+/**
+ * Load crunch decoder module
+ * @param {any} options - Loader options
+ * @returns {Promise<any>} Promise of Module object
+ */
+async function loadCrunch(options) {
+    if (crunchModule) {
+        return crunchModule;
+    }
+    let loadCrunchDecoder = await (0, worker_utils_1.loadLibrary)('crunch.js', 'textures', options);
+    // Depends on how import happened...
+    // @ts-ignore TS2339: Property does not exist on type
+    loadCrunchDecoder = loadCrunchDecoder || globalThis.loadCrunchDecoder;
+    crunchModule = loadCrunchDecoder();
+    return crunchModule;
+}

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

@@ -0,0 +1,30 @@
+/**
+ * parse data with a Binomial Basis_Universal module
+ * @param {ArrayBuffer} data
+ * @param {*} options
+ * @returns compressed texture data
+ */
+export default function parseBasis(data: ArrayBuffer, options: any): Promise<({
+    width: any;
+    height: any;
+    data: Uint8Array;
+    compressed: any;
+    alphaFlag: any;
+    format: any;
+} | null)[] | ({
+    width: any;
+    height: any;
+    data: Uint8Array;
+    compressed: any;
+    hasAlpha: any;
+    format: any;
+} | null)[][] | null>;
+/**
+ * Select transcode format from the list of supported formats
+ * @returns key for OutputFormat map
+ */
+export function selectSupportedBasisFormat(): "etc1" | "etc2" | "astc-4x4" | "rgb565" | {
+    alpha: string;
+    noAlpha: string;
+};
+//# sourceMappingURL=parse-basis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-basis.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-basis.js"],"names":[],"mappings":"AAiDA;;;;;GAKG;AACH,yCAJW,WAAW;;;;;;;;;;;;;;sBA4BrB;AA8KD;;;GAGG;AACH;;;EAoBC"}

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

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectSupportedBasisFormat = void 0;
+const basis_module_loader_1 = require("./basis-module-loader");
+const gl_extensions_1 = require("../gl-extensions");
+const texture_formats_1 = require("../utils/texture-formats");
+const parse_ktx_1 = require("./parse-ktx");
+const OutputFormat = {
+    etc1: {
+        basisFormat: 0,
+        compressed: true,
+        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
+    },
+    etc2: { basisFormat: 1, compressed: true },
+    bc1: {
+        basisFormat: 2,
+        compressed: true,
+        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
+    },
+    bc3: {
+        basisFormat: 3,
+        compressed: true,
+        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT
+    },
+    bc4: { basisFormat: 4, compressed: true },
+    bc5: { basisFormat: 5, compressed: true },
+    'bc7-m6-opaque-only': { basisFormat: 6, compressed: true },
+    'bc7-m5': { basisFormat: 7, compressed: true },
+    'pvrtc1-4-rgb': {
+        basisFormat: 8,
+        compressed: true,
+        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
+    },
+    'pvrtc1-4-rgba': {
+        basisFormat: 9,
+        compressed: true,
+        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+    },
+    'astc-4x4': {
+        basisFormat: 10,
+        compressed: true,
+        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR
+    },
+    'atc-rgb': { basisFormat: 11, compressed: true },
+    'atc-rgba-interpolated-alpha': { basisFormat: 12, compressed: true },
+    rgba32: { basisFormat: 13, compressed: false },
+    rgb565: { basisFormat: 14, compressed: false },
+    bgr565: { basisFormat: 15, compressed: false },
+    rgba4444: { basisFormat: 16, compressed: false }
+};
+/**
+ * parse data with a Binomial Basis_Universal module
+ * @param {ArrayBuffer} data
+ * @param {*} options
+ * @returns compressed texture data
+ */
+async function parseBasis(data, options) {
+    if (options.basis.containerFormat === 'auto') {
+        if ((0, parse_ktx_1.isKTX)(data)) {
+            const fileConstructors = await (0, basis_module_loader_1.loadBasisEncoderModule)(options);
+            return parseKTX2File(fileConstructors.KTX2File, data, options);
+        }
+        const { BasisFile } = await (0, basis_module_loader_1.loadBasisTrascoderModule)(options);
+        return parseBasisFile(BasisFile, data, options);
+    }
+    switch (options.basis.module) {
+        case 'encoder':
+            const fileConstructors = await (0, basis_module_loader_1.loadBasisEncoderModule)(options);
+            switch (options.basis.containerFormat) {
+                case 'ktx2':
+                    return parseKTX2File(fileConstructors.KTX2File, data, options);
+                case 'basis':
+                default:
+                    return parseBasisFile(fileConstructors.BasisFile, data, options);
+            }
+        case 'transcoder':
+        default:
+            const { BasisFile } = await (0, basis_module_loader_1.loadBasisTrascoderModule)(options);
+            return parseBasisFile(BasisFile, data, options);
+    }
+}
+exports.default = parseBasis;
+/**
+ * Parse *.basis file data
+ * @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;
+        }
+        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();
+    }
+}
+/**
+ * Parse the particular level image of a basis file
+ * @param {*} basisFile
+ * @param {*} imageIndex
+ * @param {*} levelIndex
+ * @param {*} options
+ * @returns compressed texture data
+ */
+function transcodeImage(basisFile, imageIndex, levelIndex, options) {
+    const width = basisFile.getImageWidth(imageIndex, levelIndex);
+    const height = basisFile.getImageHeight(imageIndex, levelIndex);
+    // See https://github.com/BinomialLLC/basis_universal/pull/83
+    const hasAlpha = basisFile.getHasAlpha( /* imageIndex, levelIndex */);
+    // Check options for output format etc
+    const { compressed, format, basisFormat } = getBasisOptions(options, hasAlpha);
+    const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
+    const decodedData = new Uint8Array(decodedSize);
+    if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
+        return null;
+    }
+    return {
+        // standard loaders.gl image category payload
+        width,
+        height,
+        data: decodedData,
+        compressed,
+        // Additional fields
+        // Add levelSize field.
+        hasAlpha,
+        format
+    };
+}
+/**
+ * Parse *.ktx2 file data
+ * @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;
+        }
+        const levelsCount = ktx2File.getLevels();
+        const levels = [];
+        for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
+            levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
+            break; // texture app can only show one level for some reason
+        }
+        return levels;
+    }
+    finally {
+        ktx2File.close();
+        ktx2File.delete();
+    }
+}
+/**
+ * Parse the particular level image of a ktx2 file
+ * @param {*} ktx2File
+ * @param {*} levelIndex
+ * @param {*} options
+ * @returns
+ */
+function transcodeKTX2Image(ktx2File, levelIndex, options) {
+    const { alphaFlag, height, width } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
+    // Check options for output format etc
+    const { compressed, format, basisFormat } = getBasisOptions(options, alphaFlag);
+    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;
+    }
+    return {
+        // standard loaders.gl image category payload
+        width,
+        height,
+        data: decodedData,
+        compressed,
+        // Additional fields
+        // Add levelSize field.
+        alphaFlag,
+        format
+    };
+}
+/**
+ * Get BasisFormat by loader format option
+ * @param {*} options
+ * @param {*} hasAlpha
+ * @returns BasisFormat data
+ */
+function getBasisOptions(options, hasAlpha) {
+    let format = options && options.basis && options.basis.format;
+    if (format === 'auto') {
+        format = selectSupportedBasisFormat();
+    }
+    if (typeof format === 'object') {
+        format = hasAlpha ? format.alpha : format.noAlpha;
+    }
+    format = format.toLowerCase();
+    return OutputFormat[format];
+}
+/**
+ * Select transcode format from the list of supported formats
+ * @returns key for OutputFormat map
+ */
+function selectSupportedBasisFormat() {
+    const supportedFormats = (0, texture_formats_1.getSupportedGPUTextureFormats)();
+    if (supportedFormats.has('astc')) {
+        return 'astc-4x4';
+    }
+    else if (supportedFormats.has('dxt')) {
+        return {
+            alpha: 'bc3',
+            noAlpha: 'bc1'
+        };
+    }
+    else if (supportedFormats.has('pvrtc')) {
+        return {
+            alpha: 'pvrtc1-4-rgba',
+            noAlpha: 'pvrtc1-4-rgb'
+        };
+    }
+    else if (supportedFormats.has('etc1')) {
+        return 'etc1';
+    }
+    else if (supportedFormats.has('etc2')) {
+        return 'etc2';
+    }
+    return 'rgb565';
+}
+exports.selectSupportedBasisFormat = selectSupportedBasisFormat;

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

@@ -0,0 +1,8 @@
+import type { TextureLevel } from '../../types';
+/**
+ * Deduces format and parses compressed texture loaded in ArrayBuffer
+ * @param data - binary data of compressed texture
+ * @returns Array of the texture levels
+ */
+export declare function parseCompressedTexture(data: ArrayBuffer): TextureLevel[];
+//# sourceMappingURL=parse-compressed-texture.d.ts.map

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

@@ -0,0 +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"}

package/dist/lib/parsers/parse-compressed-texture.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCompressedTexture = void 0;
+const parse_ktx_1 = require("./parse-ktx");
+const parse_dds_1 = require("./parse-dds");
+const parse_pvr_1 = require("./parse-pvr");
+/**
+ * Deduces format and parses compressed texture loaded in ArrayBuffer
+ * @param data - binary data of compressed texture
+ * @returns Array of the texture levels
+ */
+function parseCompressedTexture(data) {
+    if ((0, parse_ktx_1.isKTX)(data)) {
+        // TODO: remove @ts-ignore when `parseKTX` output is normalized to loaders.gl texture format
+        // @ts-ignore
+        return (0, parse_ktx_1.parseKTX)(data);
+    }
+    if ((0, parse_dds_1.isDDS)(data)) {
+        return (0, parse_dds_1.parseDDS)(data);
+    }
+    if ((0, parse_pvr_1.isPVR)(data)) {
+        return (0, parse_pvr_1.parsePVR)(data);
+    }
+    throw new Error('Texture container format not recognized');
+}
+exports.parseCompressedTexture = parseCompressedTexture;

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

@@ -0,0 +1,9 @@
+import type { TextureLevel } from '../../types';
+/**
+ * Parse texture data as "CRN" format.
+ * Function is "async" as emscriptified decoder module is loaded asyncronously
+ * @param data - binary data of compressed texture
+ * @returns Promise of Array of the texture levels
+ */
+export declare function parseCrunch(data: any, options: any): Promise<TextureLevel[]>;
+//# sourceMappingURL=parse-crunch.d.ts.map

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

@@ -0,0 +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"}