@predy-js/render-interface 0.3.0-beta.19 → 0.3.0-beta.190

package/dist/index.mjs

@@ -2,7 +2,7 @@
  * Name: @predy-js/render-interface
  * Description: undefined
  * Author: undefined
- * Version: v0.3.0-beta.19
+ * Version: v0.3.0-beta.190
  */
 
 /******************************************************************************
@@ -19,7 +19,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 var extendStatics = function(d, b) {
     extendStatics = Object.setPrototypeOf ||
@@ -151,24 +151,51 @@ var TextureSourceType;
 
 var GPUBufferOptionsMemoryShared = 1 << 1;
 
-var _a$6, _b$3;
+var _a$7, _b$3;
 // @ts-expect-error safe to assign
 var constants = {};
-{
-    if (typeof WebGL2RenderingContext === 'function') {
-        copy(WebGL2RenderingContext);
-    }
-    else if (typeof WebGLRenderingContext !== 'undefined') {
-        copy(WebGLRenderingContext);
-        copy(WebGLRenderingContext.prototype);
-    }
-    else {
-        //ios 16 lockdown mode
-        consoleError('WebGL not in global');
-    }
+if (typeof WebGL2RenderingContext === 'function') {
+    copy(WebGL2RenderingContext);
 }
-// @ts-expect-error set default value
-constants['HALF_FLOAT'] = 5131;
+else if (typeof WebGLRenderingContext !== 'undefined') {
+    copy(WebGLRenderingContext);
+    copy(WebGLRenderingContext.prototype);
+}
+else {
+    //ios 16 lockdown mode
+    consoleError('WebGL not in global');
+}
+Object.assign(constants, {
+    HALF_FLOAT: 5131,
+    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,
+});
 function copy(target) {
     for (var name_1 in target) {
         if (/^[A-Z_]/.test(name_1)) {
@@ -177,15 +204,15 @@ function copy(target) {
         }
     }
 }
-var map = (_a$6 = {},
-    _a$6[constants.INT] = Int32Array,
-    _a$6[constants.FLOAT] = Float32Array,
-    _a$6[constants.SHORT] = Int16Array,
-    _a$6[constants.BYTE] = Int8Array,
-    _a$6[constants.UNSIGNED_BYTE] = Uint8Array,
-    _a$6[constants.UNSIGNED_INT] = Uint32Array,
-    _a$6[constants.UNSIGNED_SHORT] = Uint16Array,
-    _a$6);
+var map = (_a$7 = {},
+    _a$7[constants.INT] = Int32Array,
+    _a$7[constants.FLOAT] = Float32Array,
+    _a$7[constants.SHORT] = Int16Array,
+    _a$7[constants.BYTE] = Int8Array,
+    _a$7[constants.UNSIGNED_BYTE] = Uint8Array,
+    _a$7[constants.UNSIGNED_INT] = Uint32Array,
+    _a$7[constants.UNSIGNED_SHORT] = Uint16Array,
+    _a$7);
 function getBytesPerElementByGLType(type) {
     var _a;
     return ((_a = map[type]) === null || _a === void 0 ? void 0 : _a.BYTES_PER_ELEMENT) || 0;
@@ -1240,9 +1267,9 @@ function requestAnimationFrame(cb) {
     return window.requestAnimationFrame(cb);
 }
 
-var _a$5;
-var DATA_DICT = (_a$5 = {},
-    _a$5[constants.FLOAT] = {
+var _a$6;
+var DATA_DICT = (_a$6 = {},
+    _a$6[constants.FLOAT] = {
         name: constants.FLOAT,
         uniform: function (gl, info, value) {
             if (value.length != undefined) {
@@ -1253,79 +1280,79 @@ var DATA_DICT = (_a$5 = {},
             }
         },
     },
-    _a$5[constants.FLOAT_VEC2] = {
+    _a$6[constants.FLOAT_VEC2] = {
         name: constants.FLOAT_VEC2,
         uniform: function (gl, info, value) {
             gl.uniform2fv(info.loc, value);
         },
     },
-    _a$5[constants.FLOAT_VEC3] = {
+    _a$6[constants.FLOAT_VEC3] = {
         name: constants.FLOAT_VEC3,
         uniform: function (gl, info, value) {
             gl.uniform3fv(info.loc, value);
         },
     },
-    _a$5[constants.FLOAT_VEC4] = {
+    _a$6[constants.FLOAT_VEC4] = {
         name: constants.FLOAT_VEC4,
         uniform: function (gl, info, value) {
             gl.uniform4fv(info.loc, value);
         },
     },
-    _a$5[constants.FLOAT_MAT2] = {
+    _a$6[constants.FLOAT_MAT2] = {
         name: constants.FLOAT_MAT2,
         uniform: function (gl, info, value) {
             gl.uniformMatrix2fv(info.loc, false, value);
         },
     },
-    _a$5[constants.FLOAT_MAT2x3] = {
+    _a$6[constants.FLOAT_MAT2x3] = {
         name: constants.FLOAT_MAT2x3,
         uniform: function (gl, info, value) {
             gl.uniformMatrix2x3fv(info.loc, false, value);
         },
     },
-    _a$5[constants.FLOAT_MAT2x4] = {
+    _a$6[constants.FLOAT_MAT2x4] = {
         name: constants.FLOAT_MAT2x4,
         uniform: function (gl, info, value) {
             gl.uniformMatrix2x3fv(info.loc, false, value);
         },
     },
-    _a$5[constants.FLOAT_MAT3] = {
+    _a$6[constants.FLOAT_MAT3] = {
         name: constants.FLOAT_MAT3,
         uniform: function (gl, info, value) {
             gl.uniformMatrix3fv(info.loc, false, value);
         },
     },
-    _a$5[constants.FLOAT_MAT3x2] = {
+    _a$6[constants.FLOAT_MAT3x2] = {
         name: constants.FLOAT_MAT3x2,
         uniform: function (gl, info, value) {
             gl.uniformMatrix3x2fv(info.loc, false, value);
         },
     },
-    _a$5[constants.FLOAT_MAT3x4] = {
+    _a$6[constants.FLOAT_MAT3x4] = {
         name: constants.FLOAT_MAT3x4,
         uniform: function (gl, info, value) {
             gl.uniformMatrix3x4fv(info.loc, false, value);
         },
     },
-    _a$5[constants.FLOAT_MAT4] = {
+    _a$6[constants.FLOAT_MAT4] = {
         name: constants.FLOAT_MAT4,
         uniform: function (gl, info, value) {
             gl.uniformMatrix4fv(info.loc, false, value);
         },
     },
-    _a$5[constants.FLOAT_MAT4x3] = {
+    _a$6[constants.FLOAT_MAT4x3] = {
         name: constants.FLOAT_MAT4x3,
         uniform: function (gl, info, value) {
             gl.uniformMatrix4x3fv(info.loc, false, value);
         },
     },
-    _a$5[constants.FLOAT_MAT4x2] = {
+    _a$6[constants.FLOAT_MAT4x2] = {
         name: constants.FLOAT_MAT4x2,
         uniform: function (gl, info, value) {
             gl.uniformMatrix4x2fv(info.loc, false, value);
         },
     },
-    _a$5[constants.INT] = {
+    _a$6[constants.INT] = {
         name: constants.INT,
         uniform: function (gl, info, value) {
             if (value.length != undefined) {
@@ -1336,49 +1363,49 @@ var DATA_DICT = (_a$5 = {},
             }
         },
     },
-    _a$5[constants.INT_VEC2] = {
+    _a$6[constants.INT_VEC2] = {
         name: constants.INT_VEC2,
         uniform: function (gl, info, value) {
             gl.uniform2iv(info.loc, value);
         },
     },
-    _a$5[constants.INT_VEC3] = {
+    _a$6[constants.INT_VEC3] = {
         name: constants.INT_VEC3,
         uniform: function (gl, info, value) {
             gl.uniform3iv(info.loc, value);
         },
     },
-    _a$5[constants.INT_VEC4] = {
+    _a$6[constants.INT_VEC4] = {
         name: constants.INT_VEC4,
         uniform: function (gl, info, value) {
             gl.uniform4iv(info.loc, value);
         },
     },
-    _a$5[constants.UNSIGNED_INT] = {
+    _a$6[constants.UNSIGNED_INT] = {
         name: constants.UNSIGNED_INT,
         uniform: function (gl, info, value) {
             gl.uniform1uiv(info.loc, value);
         },
     },
-    _a$5[constants.UNSIGNED_INT_VEC2] = {
+    _a$6[constants.UNSIGNED_INT_VEC2] = {
         name: constants.UNSIGNED_INT_VEC2,
         uniform: function (gl, info, value) {
             gl.uniform2uiv(info.loc, value);
         },
     },
-    _a$5[constants.UNSIGNED_INT_VEC3] = {
+    _a$6[constants.UNSIGNED_INT_VEC3] = {
         name: constants.UNSIGNED_INT_VEC3,
         uniform: function (gl, info, value) {
             gl.uniform3uiv(info.loc, value);
         },
     },
-    _a$5[constants.UNSIGNED_INT_VEC4] = {
+    _a$6[constants.UNSIGNED_INT_VEC4] = {
         name: constants.UNSIGNED_INT_VEC4,
         uniform: function (gl, info, value) {
             gl.uniform4uiv(info.loc, value);
         },
     },
-    _a$5[constants.BOOL] = {
+    _a$6[constants.BOOL] = {
         name: constants.BOOL,
         uniform: function (gl, info, value) {
             if (value.length != undefined) {
@@ -1389,33 +1416,33 @@ var DATA_DICT = (_a$5 = {},
             }
         },
     },
-    _a$5[constants.BOOL_VEC2] = {
+    _a$6[constants.BOOL_VEC2] = {
         name: constants.BOOL_VEC2,
         uniform: function (gl, info, value) {
             gl.uniform2iv(info.loc, value);
         },
     },
-    _a$5[constants.BOOL_VEC4] = {
+    _a$6[constants.BOOL_VEC4] = {
         name: constants.BOOL_VEC4,
         uniform: function (gl, info, value) {
             gl.uniform4iv(info.loc, value);
         },
     },
-    _a$5[constants.BOOL_VEC3] = {
+    _a$6[constants.BOOL_VEC3] = {
         name: constants.BOOL_VEC3,
         uniform: function (gl, info, value) {
             gl.uniform3iv(info.loc, value);
         },
     },
-    _a$5[constants.SAMPLER_2D] = {
+    _a$6[constants.SAMPLER_2D] = {
         name: constants.SAMPLER_2D,
         uniform: assignTexUniform,
     },
-    _a$5[constants.SAMPLER_CUBE] = {
+    _a$6[constants.SAMPLER_CUBE] = {
         name: constants.SAMPLER_CUBE,
         uniform: assignTexUniform,
     },
-    _a$5);
+    _a$6);
 function assignTexUniform(gl, info, value, renderer) {
     if (value) {
         if (info.size > 1) {
@@ -1449,7 +1476,7 @@ function assignTextureLoc(gl, info, value, renderer, index) {
     }
 }
 
-var _a$4, _b$2;
+var _a$5, _b$2;
 var BlockUniformInfoOffset = 1;
 var BlockUniformInfoByteLength = 8;
 var BlockUniformInfoType = 0;
@@ -1562,35 +1589,35 @@ var arrSetter = function (type) { return function setArray(value, info, name, ra
 var setFloat32Array = arrSetter(Float32Array);
 var setInt32Array = arrSetter(Int32Array);
 var setUInt8Array = arrSetter(Uint8Array);
-var MemorySetter = (_a$4 = {},
-    _a$4[constants.FLOAT] = numberSetter(Float32Array),
-    _a$4[constants.INT] = numberSetter(Int32Array),
-    _a$4[constants.UNSIGNED_INT] = numberSetter(Uint32Array),
-    _a$4[constants.SHORT] = numberSetter(Int16Array),
-    _a$4[constants.BOOL] = numberSetter(Uint8Array),
-    _a$4[constants.UNSIGNED_SHORT] = numberSetter(Uint16Array),
-    _a$4[constants.FLOAT_VEC2] = setFloat32Array,
-    _a$4[constants.FLOAT_VEC3] = setFloat32Array,
-    _a$4[constants.FLOAT_VEC4] = setFloat32Array,
-    _a$4[constants.FLOAT_MAT2] = setFloat32Array,
-    _a$4[constants.FLOAT_MAT3] = setFloat32Array,
-    _a$4[constants.FLOAT_MAT4] = setFloat32Array,
-    _a$4[constants.FLOAT_MAT2x3] = setFloat32Array,
-    _a$4[constants.FLOAT_MAT2x4] = setFloat32Array,
-    _a$4[constants.FLOAT_MAT4x3] = setFloat32Array,
-    _a$4[constants.FLOAT_MAT4x2] = setFloat32Array,
-    _a$4[constants.FLOAT_MAT3x4] = setFloat32Array,
-    _a$4[constants.FLOAT_MAT3x2] = setFloat32Array,
-    _a$4[constants.INT_VEC2] = setInt32Array,
-    _a$4[constants.INT_VEC3] = setInt32Array,
-    _a$4[constants.INT_VEC4] = setInt32Array,
-    _a$4[constants.UNSIGNED_INT_VEC2] = setInt32Array,
-    _a$4[constants.UNSIGNED_INT_VEC3] = setInt32Array,
-    _a$4[constants.UNSIGNED_INT_VEC4] = setInt32Array,
-    _a$4[constants.BOOL_VEC2] = setUInt8Array,
-    _a$4[constants.BOOL_VEC3] = setUInt8Array,
-    _a$4[constants.BOOL_VEC4] = setUInt8Array,
-    _a$4);
+var MemorySetter = (_a$5 = {},
+    _a$5[constants.FLOAT] = numberSetter(Float32Array),
+    _a$5[constants.INT] = numberSetter(Int32Array),
+    _a$5[constants.UNSIGNED_INT] = numberSetter(Uint32Array),
+    _a$5[constants.SHORT] = numberSetter(Int16Array),
+    _a$5[constants.BOOL] = numberSetter(Uint8Array),
+    _a$5[constants.UNSIGNED_SHORT] = numberSetter(Uint16Array),
+    _a$5[constants.FLOAT_VEC2] = setFloat32Array,
+    _a$5[constants.FLOAT_VEC3] = setFloat32Array,
+    _a$5[constants.FLOAT_VEC4] = setFloat32Array,
+    _a$5[constants.FLOAT_MAT2] = setFloat32Array,
+    _a$5[constants.FLOAT_MAT3] = setFloat32Array,
+    _a$5[constants.FLOAT_MAT4] = setFloat32Array,
+    _a$5[constants.FLOAT_MAT2x3] = setFloat32Array,
+    _a$5[constants.FLOAT_MAT2x4] = setFloat32Array,
+    _a$5[constants.FLOAT_MAT4x3] = setFloat32Array,
+    _a$5[constants.FLOAT_MAT4x2] = setFloat32Array,
+    _a$5[constants.FLOAT_MAT3x4] = setFloat32Array,
+    _a$5[constants.FLOAT_MAT3x2] = setFloat32Array,
+    _a$5[constants.INT_VEC2] = setInt32Array,
+    _a$5[constants.INT_VEC3] = setInt32Array,
+    _a$5[constants.INT_VEC4] = setInt32Array,
+    _a$5[constants.UNSIGNED_INT_VEC2] = setInt32Array,
+    _a$5[constants.UNSIGNED_INT_VEC3] = setInt32Array,
+    _a$5[constants.UNSIGNED_INT_VEC4] = setInt32Array,
+    _a$5[constants.BOOL_VEC2] = setUInt8Array,
+    _a$5[constants.BOOL_VEC3] = setUInt8Array,
+    _a$5[constants.BOOL_VEC4] = setUInt8Array,
+    _a$5);
 var ItemPerValueMap = (_b$2 = {},
     _b$2[constants.FLOAT] = 1,
     _b$2[constants.INT] = 1,
@@ -1791,13 +1818,18 @@ var GLProgram = /** @class */ (function () {
         }
     };
     GLProgram.prototype.getSemanticValue = function (state, semanticName) {
-        var renderPassSemantics = state.currentPass.semantics;
-        var renderFrameSemantics = state.currentFrame.semantics;
-        if (renderPassSemantics.hasSemanticValue(semanticName)) {
-            return renderPassSemantics.getSemanticValue(semanticName, state);
+        if (typeof semanticName === 'function') {
+            return semanticName(state);
         }
-        else if (renderFrameSemantics.hasSemanticValue(semanticName)) {
-            return renderFrameSemantics.getSemanticValue(semanticName, state);
+        else {
+            var renderPassSemantics = state.currentPass.semantics;
+            var renderFrameSemantics = state.currentFrame.semantics;
+            if (renderPassSemantics.hasSemanticValue(semanticName)) {
+                return renderPassSemantics.getSemanticValue(semanticName, state);
+            }
+            else if (renderFrameSemantics.hasSemanticValue(semanticName)) {
+                return renderFrameSemantics.getSemanticValue(semanticName, state);
+            }
         }
     };
     GLProgram.prototype.setupUniforms = function (state) {
@@ -1938,21 +1970,21 @@ var GLProgram = /** @class */ (function () {
     return GLProgram;
 }());
 
-var _a$3;
+var _a$4;
 var ShaderType;
 (function (ShaderType) {
     ShaderType[ShaderType["vertex"] = 0] = "vertex";
     ShaderType[ShaderType["fragment"] = 1] = "fragment";
 })(ShaderType || (ShaderType = {}));
-var downgradeKeywords = (_a$3 = {},
-    _a$3[ShaderType.vertex] = {
+var downgradeKeywords = (_a$4 = {},
+    _a$4[ShaderType.vertex] = {
         in: 'attribute',
         out: 'varying',
     },
-    _a$3[ShaderType.fragment] = {
+    _a$4[ShaderType.fragment] = {
         in: 'varying',
     },
-    _a$3);
+    _a$4);
 var shaderSeed = 1;
 var GLShaderLibrary = /** @class */ (function () {
     function GLShaderLibrary(renderer) {
@@ -2430,7 +2462,7 @@ function registerCompressedTexture(gl) {
     return 0;
 }
 
-var _a$2, _b$1;
+var _a$3, _b$1;
 var flipCanvas;
 var imageBitMapAvailable$1 = typeof ImageBitmap === 'function' && typeof createImageBitmap == 'function';
 var GLTexture = /** @class */ (function () {
@@ -2767,14 +2799,14 @@ function nearestPowerOfTwo(value) {
 function isPowerOfTwo(value) {
     return (value & (value - 1)) === 0 && value !== 0;
 }
-var FORMAT_HALF_FLOAT = (_a$2 = {},
-    _a$2[constants.RGBA] = 34842,
-    _a$2[constants.RGB] = 34843,
-    _a$2[constants.ALPHA] = 33325,
-    _a$2[constants.RED] = 33325,
-    _a$2[constants.LUMINANCE_ALPHA] = 33327,
-    _a$2[constants.LUMINANCE] = 33325,
-    _a$2);
+var FORMAT_HALF_FLOAT = (_a$3 = {},
+    _a$3[constants.RGBA] = 34842,
+    _a$3[constants.RGB] = 34843,
+    _a$3[constants.ALPHA] = 33325,
+    _a$3[constants.RED] = 33325,
+    _a$3[constants.LUMINANCE_ALPHA] = 33327,
+    _a$3[constants.LUMINANCE] = 33325,
+    _a$3);
 var FORMAT_FLOAT = (_b$1 = {},
     _b$1[constants.RGBA] = 34836,
     _b$1[constants.RGB] = 34837,
@@ -3564,110 +3596,394 @@ function loadImageAsync(imgOrURL, options) {
     });
 }
 
-var HEADER_LEN = 12 + 13 * 4; // identifier + header elements (not including key value meta-data pairs)
-var COMPRESSED_2D = 0; // uses a gl.compressedTexImage2D()
-//const COMPRESSED_3D = 1; // uses a gl.compressedTexImage3D()
-var TEX_2D = 2; // uses a gl.texImage2D()
-//const TEX_3D = 3; // uses a gl.texImage3D()
-var KhronosTextureContainer = /** @class */ (function () {
-    function KhronosTextureContainer(arrayBuffer, facesExpected, baseOffset) {
-        if (baseOffset === void 0) { baseOffset = 0; }
-        this.arrayBuffer = arrayBuffer;
-        this.baseOffset = baseOffset;
-        // Test that it is a ktx formatted file, based on the first 12 bytes, character representation is:
-        // '´', 'K', 'T', 'X', ' ', '1', '1', 'ª', '\r', '\n', '\x1A', '\n'
-        // 0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A
-        var identifier = new Uint8Array(this.arrayBuffer, this.baseOffset, 12);
-        if (identifier[0] !== 0xab ||
-            identifier[1] !== 0x4b ||
-            identifier[2] !== 0x54 ||
-            identifier[3] !== 0x58 ||
-            identifier[4] !== 0x20 ||
-            identifier[5] !== 0x31 ||
-            identifier[6] !== 0x31 ||
-            identifier[7] !== 0xbb ||
-            identifier[8] !== 0x0d ||
-            identifier[9] !== 0x0a ||
-            identifier[10] !== 0x1a ||
-            identifier[11] !== 0x0a) {
-            throw Error('texture missing KTX identifier');
-        }
-        // load the reset of the header in native-ri 32 bit uint
-        var dataSize = Uint32Array.BYTES_PER_ELEMENT;
-        var headerDataView = new DataView(this.arrayBuffer, this.baseOffset + 12, 13 * dataSize);
-        var endianness = headerDataView.getUint32(0, true);
-        var littleEndian = endianness === 0x04030201;
-        this.glType = headerDataView.getUint32(1 * dataSize, littleEndian); // must be 0 for compressed textures
-        this.glTypeSize = headerDataView.getUint32(2 * dataSize, littleEndian); // must be 1 for compressed textures
-        this.glFormat = headerDataView.getUint32(3 * dataSize, littleEndian); // must be 0 for compressed textures
-        this.glInternalFormat = headerDataView.getUint32(4 * dataSize, littleEndian); // the value of arg passed to gl.compressedTexImage2D(,,x,,,,)
-        this.glBaseInternalFormat = headerDataView.getUint32(5 * dataSize, littleEndian); // specify GL_RGB, GL_RGBA, GL_ALPHA, etc (un-compressed only)
-        this.pixelWidth = headerDataView.getUint32(6 * dataSize, littleEndian); // level 0 value of arg passed to gl.compressedTexImage2D(,,,x,,,)
-        this.pixelHeight = headerDataView.getUint32(7 * dataSize, littleEndian); // level 0 value of arg passed to gl.compressedTexImage2D(,,,,x,,)
-        this.pixelDepth = headerDataView.getUint32(8 * dataSize, littleEndian); // level 0 value of arg passed to gl.compressedTexImage3D(,,,,,x,,)
-        this.numberOfArrayElements = headerDataView.getUint32(9 * dataSize, littleEndian); // used for texture arrays
-        this.numberOfFaces = headerDataView.getUint32(10 * dataSize, littleEndian); // used for cubemap textures, should either be 1 or 6
-        this.numberOfMipmapLevels = headerDataView.getUint32(11 * dataSize, littleEndian); // number of levels; disregard possibility of 0 for compressed textures
-        this.bytesOfKeyValueData = headerDataView.getUint32(12 * dataSize, littleEndian); // the amount of space after the header for meta-data
-        // value of zero is an indication to generate mipmaps @ runtime.  Not usually allowed for compressed, so disregard.
-        this.numberOfMipmapLevels = Math.max(1, this.numberOfMipmapLevels);
-        if (this.pixelHeight === 0 || this.pixelDepth !== 0) {
-            consoleWarn('only 2D textures currently supported');
-            return;
-        }
-        if (this.numberOfArrayElements !== 0) {
-            consoleWarn('texture arrays not currently supported');
-            return;
-        }
-        if (this.numberOfFaces !== facesExpected) {
-            consoleWarn('number of faces expected' + facesExpected + ', but found ' + this.numberOfFaces);
-            return;
-        }
-        // we now have a completely validated file, so could use existence of loadType as success
-        // would need to make this more elaborate & adjust checks above to support more than one load type
-        if (this.glType === 0) {
-            this.loadType = COMPRESSED_2D;
-        }
-        else {
-            this.loadType = TEX_2D;
-        }
+///////////////////////////////////////////////////
+// KTX2 Header.
+///////////////////////////////////////////////////
+const KHR_SUPERCOMPRESSION_NONE = 0;
+///////////////////////////////////////////////////
+// Data Format Descriptor (DFD).
+///////////////////////////////////////////////////
+const KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT = 0;
+const KHR_DF_VENDORID_KHRONOS = 0;
+const KHR_DF_VERSION = 2;
+const KHR_DF_MODEL_UNSPECIFIED = 0;
+const KHR_DF_FLAG_ALPHA_STRAIGHT = 0;
+const KHR_DF_TRANSFER_SRGB = 2;
+const KHR_DF_PRIMARIES_BT709 = 1;
+const KHR_DF_SAMPLE_DATATYPE_SIGNED = 0x40;
+///////////////////////////////////////////////////
+// VK FORMAT.
+///////////////////////////////////////////////////
+const VK_FORMAT_UNDEFINED = 0;
+const VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157;
+const VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158;
+const VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159;
+const VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160;
+const VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161;
+const VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162;
+const VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163;
+const VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164;
+const VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165;
+const VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166;
+const VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167;
+const VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168;
+const VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169;
+const VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170;
+const VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171;
+const VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172;
+const VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173;
+const VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174;
+const VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175;
+const VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176;
+const VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177;
+const VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178;
+const VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179;
+const VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180;
+const VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181;
+const VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182;
+const VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183;
+const VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184;
+
+/**
+ * Represents an unpacked KTX 2.0 texture container. Data for individual mip levels are stored in
+ * the `.levels` array, typically compressed in Basis Universal formats. Additional properties
+ * provide metadata required to process, transcode, and upload these textures.
+ */
+class KTX2Container {
+  constructor() {
+    /**
+     * Specifies the image format using Vulkan VkFormat enum values. When using Basis Universal
+     * texture formats, `vkFormat` must be VK_FORMAT_UNDEFINED.
+     */
+    this.vkFormat = VK_FORMAT_UNDEFINED;
+    /**
+     * Size of the data type in bytes used to upload the data to a graphics API. When `vkFormat` is
+     * VK_FORMAT_UNDEFINED, `typeSize` must be 1.
+     */
+    this.typeSize = 1;
+    /** Width of the texture image for level 0, in pixels. */
+    this.pixelWidth = 0;
+    /** Height of the texture image for level 0, in pixels. */
+    this.pixelHeight = 0;
+    /** Depth of the texture image for level 0, in pixels (3D textures only). */
+    this.pixelDepth = 0;
+    /** Number of array elements (array textures only). */
+    this.layerCount = 0;
+    /**
+     * Number of cubemap faces. For cubemaps and cubemap arrays, `faceCount` must be 6. For all
+     * other textures, `faceCount` must be 1. Cubemap faces are stored in +X, -X, +Y, -Y, +Z, -Z
+     * order.
+     */
+    this.faceCount = 1;
+    /** Indicates which supercompression scheme has been applied to mip level images, if any. */
+    this.supercompressionScheme = KHR_SUPERCOMPRESSION_NONE;
+    /** Mip levels, ordered largest (original) to smallest (~1px). */
+    this.levels = [];
+    /** Data Format Descriptor. */
+    this.dataFormatDescriptor = [{
+      vendorId: KHR_DF_VENDORID_KHRONOS,
+      descriptorType: KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT,
+      descriptorBlockSize: 0,
+      versionNumber: KHR_DF_VERSION,
+      colorModel: KHR_DF_MODEL_UNSPECIFIED,
+      colorPrimaries: KHR_DF_PRIMARIES_BT709,
+      transferFunction: KHR_DF_TRANSFER_SRGB,
+      flags: KHR_DF_FLAG_ALPHA_STRAIGHT,
+      texelBlockDimension: [0, 0, 0, 0],
+      bytesPlane: [0, 0, 0, 0, 0, 0, 0, 0],
+      samples: []
+    }];
+    /** Key/Value Data. */
+    this.keyValue = {};
+    /** Supercompression Global Data. */
+    this.globalData = null;
+  }
+}
+
+class BufferReader {
+  constructor(data, byteOffset, byteLength, littleEndian) {
+    this._dataView = void 0;
+    this._littleEndian = void 0;
+    this._offset = void 0;
+    this._dataView = new DataView(data.buffer, data.byteOffset + byteOffset, byteLength);
+    this._littleEndian = littleEndian;
+    this._offset = 0;
+  }
+  _nextUint8() {
+    const value = this._dataView.getUint8(this._offset);
+    this._offset += 1;
+    return value;
+  }
+  _nextUint16() {
+    const value = this._dataView.getUint16(this._offset, this._littleEndian);
+    this._offset += 2;
+    return value;
+  }
+  _nextUint32() {
+    const value = this._dataView.getUint32(this._offset, this._littleEndian);
+    this._offset += 4;
+    return value;
+  }
+  _nextUint64() {
+    const left = this._dataView.getUint32(this._offset, this._littleEndian);
+    const right = this._dataView.getUint32(this._offset + 4, this._littleEndian);
+    // TODO(cleanup): Just test this...
+    // const value = this._littleEndian ? left + (2 ** 32 * right) : (2 ** 32 * left) + right;
+    const value = left + 2 ** 32 * right;
+    this._offset += 8;
+    return value;
+  }
+  _nextInt32() {
+    const value = this._dataView.getInt32(this._offset, this._littleEndian);
+    this._offset += 4;
+    return value;
+  }
+  _nextUint8Array(len) {
+    const value = new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + this._offset, len);
+    this._offset += len;
+    return value;
+  }
+  _skip(bytes) {
+    this._offset += bytes;
+    return this;
+  }
+  _scan(maxByteLength, term = 0x00) {
+    const byteOffset = this._offset;
+    let byteLength = 0;
+    while (this._dataView.getUint8(this._offset) !== term && byteLength < maxByteLength) {
+      byteLength++;
+      this._offset++;
     }
-    KhronosTextureContainer.prototype.mipmaps = function (loadMipmaps) {
-        var mipmaps = [];
-        // initialize width & height for level 1
-        var dataOffset = HEADER_LEN + this.bytesOfKeyValueData;
-        var width = this.pixelWidth;
-        var height = this.pixelHeight;
-        var mipmapCount = loadMipmaps ? this.numberOfMipmapLevels : 1;
-        for (var level = 0; level < mipmapCount; level++) {
-            var imageSize = new Int32Array(this.arrayBuffer, this.baseOffset + dataOffset, 1)[0]; // size per face, since not supporting array cubemaps
-            for (var face = 0; face < this.numberOfFaces; face++) {
-                var byteArray = new Uint8Array(this.arrayBuffer, this.baseOffset + dataOffset + 4, imageSize);
-                mipmaps.push({
-                    data: byteArray,
-                    width: width,
-                    height: height,
-                });
-                dataOffset += imageSize + 4; // size of the image + 4 for the imageSize field
-                dataOffset += 3 - ((imageSize + 3) % 4); // add padding for odd sized image
-            }
-            width = Math.max(1.0, width * 0.5);
-            height = Math.max(1.0, height * 0.5);
-        }
-        return mipmaps;
-    };
-    return KhronosTextureContainer;
-}());
+    if (byteLength < maxByteLength) this._offset++;
+    return new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + byteOffset, byteLength);
+  }
+}
+///////////////////////////////////////////////////
+// KTX2 Header.
+///////////////////////////////////////////////////
+const KTX2_ID = [
+// '´', 'K', 'T', 'X', '2', '0', 'ª', '\r', '\n', '\x1A', '\n'
+0xab, 0x4b, 0x54, 0x58, 0x20, 0x32, 0x30, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a];
+/** Decodes an ArrayBuffer to text. */
+function decodeText(buffer) {
+  return new TextDecoder().decode(buffer);
+}
+
+/**
+ * Parses a KTX 2.0 file, returning an unpacked {@link KTX2Container} instance with all associated
+ * data. The container's mip levels and other binary data are pointers into the original file, not
+ * copies, so the original file should not be overwritten after reading.
+ *
+ * @param data Bytes of KTX 2.0 file, as Uint8Array or Buffer.
+ */
+function read(data) {
+  ///////////////////////////////////////////////////
+  // KTX 2.0 Identifier.
+  ///////////////////////////////////////////////////
+  const id = new Uint8Array(data.buffer, data.byteOffset, KTX2_ID.length);
+  if (id[0] !== KTX2_ID[0] ||
+  // '´'
+  id[1] !== KTX2_ID[1] ||
+  // 'K'
+  id[2] !== KTX2_ID[2] ||
+  // 'T'
+  id[3] !== KTX2_ID[3] ||
+  // 'X'
+  id[4] !== KTX2_ID[4] ||
+  // ' '
+  id[5] !== KTX2_ID[5] ||
+  // '2'
+  id[6] !== KTX2_ID[6] ||
+  // '0'
+  id[7] !== KTX2_ID[7] ||
+  // 'ª'
+  id[8] !== KTX2_ID[8] ||
+  // '\r'
+  id[9] !== KTX2_ID[9] ||
+  // '\n'
+  id[10] !== KTX2_ID[10] ||
+  // '\x1A'
+  id[11] !== KTX2_ID[11] // '\n'
+  ) {
+    throw new Error('Missing KTX 2.0 identifier.');
+  }
+  const container = new KTX2Container();
+  ///////////////////////////////////////////////////
+  // Header.
+  ///////////////////////////////////////////////////
+  const headerByteLength = 17 * Uint32Array.BYTES_PER_ELEMENT;
+  const headerReader = new BufferReader(data, KTX2_ID.length, headerByteLength, true);
+  container.vkFormat = headerReader._nextUint32();
+  container.typeSize = headerReader._nextUint32();
+  container.pixelWidth = headerReader._nextUint32();
+  container.pixelHeight = headerReader._nextUint32();
+  container.pixelDepth = headerReader._nextUint32();
+  container.layerCount = headerReader._nextUint32();
+  container.faceCount = headerReader._nextUint32();
+  const levelCount = headerReader._nextUint32();
+  container.supercompressionScheme = headerReader._nextUint32();
+  const dfdByteOffset = headerReader._nextUint32();
+  const dfdByteLength = headerReader._nextUint32();
+  const kvdByteOffset = headerReader._nextUint32();
+  const kvdByteLength = headerReader._nextUint32();
+  const sgdByteOffset = headerReader._nextUint64();
+  const sgdByteLength = headerReader._nextUint64();
+  ///////////////////////////////////////////////////
+  // Level Index.
+  ///////////////////////////////////////////////////
+  const levelByteLength = levelCount * 3 * 8;
+  const levelReader = new BufferReader(data, KTX2_ID.length + headerByteLength, levelByteLength, true);
+  for (let i = 0; i < levelCount; i++) {
+    container.levels.push({
+      levelData: new Uint8Array(data.buffer, data.byteOffset + levelReader._nextUint64(), levelReader._nextUint64()),
+      uncompressedByteLength: levelReader._nextUint64()
+    });
+  }
+  ///////////////////////////////////////////////////
+  // Data Format Descriptor (DFD).
+  ///////////////////////////////////////////////////
+  const dfdReader = new BufferReader(data, dfdByteOffset, dfdByteLength, true);
+  const dfd = {
+    vendorId: dfdReader._skip(4 /* totalSize */)._nextUint16(),
+    descriptorType: dfdReader._nextUint16(),
+    versionNumber: dfdReader._nextUint16(),
+    descriptorBlockSize: dfdReader._nextUint16(),
+    colorModel: dfdReader._nextUint8(),
+    colorPrimaries: dfdReader._nextUint8(),
+    transferFunction: dfdReader._nextUint8(),
+    flags: dfdReader._nextUint8(),
+    texelBlockDimension: [dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8()],
+    bytesPlane: [dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8()],
+    samples: []
+  };
+  const sampleStart = 6;
+  const sampleWords = 4;
+  const numSamples = (dfd.descriptorBlockSize / 4 - sampleStart) / sampleWords;
+  for (let i = 0; i < numSamples; i++) {
+    const sample = {
+      bitOffset: dfdReader._nextUint16(),
+      bitLength: dfdReader._nextUint8(),
+      channelType: dfdReader._nextUint8(),
+      samplePosition: [dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8()],
+      sampleLower: -Infinity,
+      sampleUpper: Infinity
+    };
+    if (sample.channelType & KHR_DF_SAMPLE_DATATYPE_SIGNED) {
+      sample.sampleLower = dfdReader._nextInt32();
+      sample.sampleUpper = dfdReader._nextInt32();
+    } else {
+      sample.sampleLower = dfdReader._nextUint32();
+      sample.sampleUpper = dfdReader._nextUint32();
+    }
+    dfd.samples[i] = sample;
+  }
+  container.dataFormatDescriptor.length = 0;
+  container.dataFormatDescriptor.push(dfd);
+  ///////////////////////////////////////////////////
+  // Key/Value Data (KVD).
+  ///////////////////////////////////////////////////
+  const kvdReader = new BufferReader(data, kvdByteOffset, kvdByteLength, true);
+  while (kvdReader._offset < kvdByteLength) {
+    const keyValueByteLength = kvdReader._nextUint32();
+    const keyData = kvdReader._scan(keyValueByteLength);
+    const key = decodeText(keyData);
+    container.keyValue[key] = kvdReader._nextUint8Array(keyValueByteLength - keyData.byteLength - 1);
+    if (key.match(/^ktx/i)) {
+      const text = decodeText(container.keyValue[key]);
+      container.keyValue[key] = text.substring(0, text.lastIndexOf('\x00'));
+    }
+    const kvPadding = keyValueByteLength % 4 ? 4 - keyValueByteLength % 4 : 0; // align(4)
+    // 4-byte alignment.
+    kvdReader._skip(kvPadding);
+  }
+  ///////////////////////////////////////////////////
+  // Supercompression Global Data (SGD).
+  ///////////////////////////////////////////////////
+  if (sgdByteLength <= 0) return container;
+  const sgdReader = new BufferReader(data, sgdByteOffset, sgdByteLength, true);
+  const endpointCount = sgdReader._nextUint16();
+  const selectorCount = sgdReader._nextUint16();
+  const endpointsByteLength = sgdReader._nextUint32();
+  const selectorsByteLength = sgdReader._nextUint32();
+  const tablesByteLength = sgdReader._nextUint32();
+  const extendedByteLength = sgdReader._nextUint32();
+  const imageDescs = [];
+  for (let i = 0; i < levelCount; i++) {
+    imageDescs.push({
+      imageFlags: sgdReader._nextUint32(),
+      rgbSliceByteOffset: sgdReader._nextUint32(),
+      rgbSliceByteLength: sgdReader._nextUint32(),
+      alphaSliceByteOffset: sgdReader._nextUint32(),
+      alphaSliceByteLength: sgdReader._nextUint32()
+    });
+  }
+  const endpointsByteOffset = sgdByteOffset + sgdReader._offset;
+  const selectorsByteOffset = endpointsByteOffset + endpointsByteLength;
+  const tablesByteOffset = selectorsByteOffset + selectorsByteLength;
+  const extendedByteOffset = tablesByteOffset + tablesByteLength;
+  const endpointsData = new Uint8Array(data.buffer, data.byteOffset + endpointsByteOffset, endpointsByteLength);
+  const selectorsData = new Uint8Array(data.buffer, data.byteOffset + selectorsByteOffset, selectorsByteLength);
+  const tablesData = new Uint8Array(data.buffer, data.byteOffset + tablesByteOffset, tablesByteLength);
+  const extendedData = new Uint8Array(data.buffer, data.byteOffset + extendedByteOffset, extendedByteLength);
+  container.globalData = {
+    endpointCount,
+    selectorCount,
+    imageDescs,
+    endpointsData,
+    selectorsData,
+    tablesData,
+    extendedData
+  };
+  return container;
+}
+
+var _a$2;
+var formatMap = (_a$2 = {},
+    _a$2[VK_FORMAT_ASTC_4x4_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR],
+    _a$2[VK_FORMAT_ASTC_4x4_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_4x4_KHR],
+    _a$2[VK_FORMAT_ASTC_6x6_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR],
+    _a$2[VK_FORMAT_ASTC_6x6_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_6x6_KHR],
+    _a$2[VK_FORMAT_ASTC_8x8_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR],
+    _a$2[VK_FORMAT_ASTC_8x8_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_8x8_KHR],
+    _a$2[VK_FORMAT_ASTC_10x10_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR],
+    _a$2[VK_FORMAT_ASTC_10x10_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_10x10_KHR],
+    _a$2[VK_FORMAT_ASTC_12x12_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR],
+    _a$2[VK_FORMAT_ASTC_12x12_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_12x12_KHR],
+    _a$2[VK_FORMAT_ASTC_5x5_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR],
+    _a$2[VK_FORMAT_ASTC_5x5_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_5x5_KHR],
+    _a$2[VK_FORMAT_ASTC_5x4_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR],
+    _a$2[VK_FORMAT_ASTC_5x4_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_5x4_KHR],
+    _a$2[VK_FORMAT_ASTC_6x5_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR],
+    _a$2[VK_FORMAT_ASTC_6x5_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_6x5_KHR],
+    _a$2[VK_FORMAT_ASTC_10x5_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR],
+    _a$2[VK_FORMAT_ASTC_10x5_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_10x5_KHR],
+    _a$2[VK_FORMAT_ASTC_8x6_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR],
+    _a$2[VK_FORMAT_ASTC_8x6_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_8x6_KHR],
+    _a$2[VK_FORMAT_ASTC_10x6_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR],
+    _a$2[VK_FORMAT_ASTC_10x6_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_10x6_KHR],
+    _a$2[VK_FORMAT_ASTC_8x5_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR],
+    _a$2[VK_FORMAT_ASTC_8x5_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_8x5_KHR],
+    _a$2[VK_FORMAT_ASTC_12x10_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR],
+    _a$2[VK_FORMAT_ASTC_12x10_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_12x10_KHR],
+    _a$2[VK_FORMAT_ASTC_10x8_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR],
+    _a$2[VK_FORMAT_ASTC_10x8_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_10x8_KHR],
+    _a$2);
 function getCompressedTextureOptions(data) {
-    var ktx = new KhronosTextureContainer(data, 1);
-    var useMipmaps = ktx.numberOfMipmapLevels >= Math.floor(Math.log2(Math.max(ktx.pixelWidth, ktx.pixelHeight)) + 1);
+    var container = read(data);
+    var width = container.pixelWidth;
+    var height = container.pixelHeight;
+    var pair = formatMap[container.vkFormat];
     return {
         sourceType: TextureSourceType.compressed,
-        type: ktx.glType,
-        target: ktx.numberOfFaces === 6 ? constants.TEXTURE_CUBE_MAP : constants.TEXTURE_2D,
-        internalFormat: ktx.glInternalFormat,
-        format: ktx.glFormat,
-        mipmaps: ktx.mipmaps(useMipmaps),
+        target: container.faceCount === 6 ? constants.TEXTURE_CUBE_MAP : constants.TEXTURE_2D,
+        format: pair[1],
+        internalFormat: pair[1],
+        type: pair[0],
+        mipmaps: container.levels.map(function (level, i) { return ({
+            data: level.levelData,
+            width: width >> i,
+            height: height >> i,
+        }); }),
     };
 }
 
@@ -3758,7 +4074,7 @@ var MarsTextureFactory = /** @class */ (function () {
         }
         else if (sourceFrom.type === TextureSourceType.compressed) {
             return this.requestBinaryAsync(sourceFrom.url).then(function (arrayBuffer) {
-                return Object.assign(getCompressedTextureOptions(arrayBuffer), config, {
+                return Object.assign(getCompressedTextureOptions(new Uint8Array(arrayBuffer)), config, {
                     sourceFrom: { url: sourceFrom.url, type: TextureSourceType.compressed },
                 });
             }, catchError);
@@ -3857,7 +4173,7 @@ var MarsTextureFactory = /** @class */ (function () {
         return Promise.all(map.map(function (key) { return _this.loadImageAsync(key); }));
     };
     MarsTextureFactory.prototype.loadCompressedTextureFromArrayBuffer = function (arrayBuffer, options) {
-        return Object.assign(getCompressedTextureOptions(arrayBuffer), options);
+        return Object.assign(getCompressedTextureOptions(new Uint8Array(arrayBuffer)), options);
     };
     MarsTextureFactory.prototype.reloadTextureAsync = function (texture) {
         var _this = this;
@@ -4482,10 +4798,10 @@ var GLMaterial = /** @class */ (function () {
             webGLState.depthFunc(currentState.depthFunc);
             webGLState.depthRange((_a = currentState.depthRange) === null || _a === void 0 ? void 0 : _a[0], (_b = currentState.depthRange) === null || _b === void 0 ? void 0 : _b[1]);
         }
+        webGLState.frontFace(currentState.frontFace);
         if (currentState.cullFaceEnabled) {
             //face
             webGLState.cullFace(currentState.cullFace);
-            webGLState.frontFace(currentState.frontFace);
         }
         if (currentState.polygonOffsetFill) {
             var polygonOffset = currentState.polygonOffset || [0, 0];
@@ -5856,7 +6172,7 @@ var MarsSharedGeometry = /** @class */ (function (_super) {
     return MarsSharedGeometry;
 }(MarsGeometry));
 
-consoleLog('version: ' + "0.3.0-beta.19");
+consoleLog('version: ' + "0.3.0-beta.190");
 var ModuleMsg = 'RI Package: @predy-js/render-interface';
 
 var RI = /*#__PURE__*/Object.freeze({