@loaders.gl/gltf 3.1.0-alpha.5 → 3.1.0-beta.1

package/dist/lib/extensions/deprecated/KHR_techniques_webgl.js

@@ -0,0 +1,81 @@
+"use strict";
+// GLTF EXTENSION: KHR_techniques_webgl
+// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_techniques_webgl
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = exports.decode = exports.name = void 0;
+const gltf_scenegraph_1 = __importDefault(require("../../api/gltf-scenegraph"));
+const KHR_TECHNIQUES_WEBGL = 'KHR_techniques_webgl';
+exports.name = KHR_TECHNIQUES_WEBGL;
+async function decode(gltfData) {
+    const gltfScenegraph = new gltf_scenegraph_1.default(gltfData);
+    const { json } = gltfScenegraph;
+    const extension = gltfScenegraph.getExtension(KHR_TECHNIQUES_WEBGL);
+    if (extension) {
+        const techniques = resolveTechniques(extension, gltfScenegraph);
+        for (const material of json.materials || []) {
+            const materialExtension = gltfScenegraph.getObjectExtension(material, KHR_TECHNIQUES_WEBGL);
+            if (materialExtension) {
+                // @ts-ignore TODO
+                material.technique = Object.assign({}, materialExtension, 
+                // @ts-ignore
+                techniques[materialExtension.technique]);
+                // @ts-ignore TODO
+                material.technique.values = resolveValues(material.technique, gltfScenegraph);
+            }
+            gltfScenegraph.removeObjectExtension(material, KHR_TECHNIQUES_WEBGL);
+        }
+        gltfScenegraph.removeExtension(KHR_TECHNIQUES_WEBGL);
+    }
+}
+exports.decode = decode;
+// eslint-disable-next-line
+async function encode(gltfData, options) {
+    // TODO
+}
+exports.encode = encode;
+function resolveTechniques(techniquesExtension, 
+// programs: {[key: string]: any}[],
+// shaders: {[key: string]: any}[],
+// techniques: {[key: string]: any}[]
+gltfScenegraph) {
+    const { programs = [], shaders = [], techniques = [] } = techniquesExtension;
+    const textDecoder = new TextDecoder();
+    shaders.forEach((shader) => {
+        if (Number.isFinite(shader.bufferView)) {
+            shader.code = textDecoder.decode(gltfScenegraph.getTypedArrayForBufferView(shader.bufferView));
+        }
+        else {
+            // TODO: handle URI shader
+            throw new Error('KHR_techniques_webgl: no shader code');
+        }
+    });
+    programs.forEach((program) => {
+        program.fragmentShader = shaders[program.fragmentShader];
+        program.vertexShader = shaders[program.vertexShader];
+    });
+    techniques.forEach((technique) => {
+        technique.program = programs[technique.program];
+    });
+    return techniques;
+}
+function resolveValues(technique, gltfScenegraph) {
+    const values = Object.assign({}, technique.values);
+    // merge values from uniforms
+    Object.keys(technique.uniforms || {}).forEach((uniform) => {
+        if (technique.uniforms[uniform].value && !(uniform in values)) {
+            values[uniform] = technique.uniforms[uniform].value;
+        }
+    });
+    // resolve textures
+    Object.keys(values).forEach((uniform) => {
+        if (typeof values[uniform] === 'object' && values[uniform].index !== undefined) {
+            // Assume this is a texture
+            // TODO: find if there are any other types that can be referenced
+            values[uniform].texture = gltfScenegraph.getTexture(values[uniform].index);
+        }
+    });
+    return values;
+}

package/dist/lib/gltf-utils/get-typed-array.d.ts

@@ -1,2 +1,3 @@
 export declare function getTypedArrayForBufferView(json: any, buffers: any, bufferViewIndex: any): Uint8Array;
 export declare function getTypedArrayForImageData(json: any, buffers: any, imageIndex: any): Uint8Array;
+//# sourceMappingURL=get-typed-array.d.ts.map

package/dist/lib/gltf-utils/get-typed-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-typed-array.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/get-typed-array.ts"],"names":[],"mappings":"AAKA,wBAAgB,0BAA0B,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,EAAE,eAAe,KAAA,cAWxE;AAID,wBAAgB,yBAAyB,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,EAAE,UAAU,KAAA,cAIlE"}

package/dist/lib/gltf-utils/get-typed-array.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypedArrayForImageData = exports.getTypedArrayForBufferView = void 0;
+// TODO - GLTFScenegraph should use these
+const assert_1 = require("../utils/assert");
+// accepts buffer view index or buffer view object
+// returns a `Uint8Array`
+function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {
+    const bufferView = json.bufferViews[bufferViewIndex];
+    (0, assert_1.assert)(bufferView);
+    // Get hold of the arrayBuffer
+    const bufferIndex = bufferView.buffer;
+    const binChunk = buffers[bufferIndex];
+    (0, assert_1.assert)(binChunk);
+    const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
+    return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
+}
+exports.getTypedArrayForBufferView = getTypedArrayForBufferView;
+// accepts accessor index or accessor object
+// returns a `Uint8Array`
+function getTypedArrayForImageData(json, buffers, imageIndex) {
+    const image = json.images[imageIndex];
+    const bufferViewIndex = json.bufferViews[image.bufferView];
+    return getTypedArrayForBufferView(json, buffers, bufferViewIndex);
+}
+exports.getTypedArrayForImageData = getTypedArrayForImageData;
+/*
+// accepts accessor index or accessor object
+// returns a typed array with type that matches the types
+export function getTypedArrayForAccessor(accessor) {
+  accessor = this.getAccessor(accessor);
+  const bufferView = this.getBufferView(accessor.bufferView);
+  const buffer = this.getBuffer(bufferView.buffer);
+  const arrayBuffer = buffer.data;
+
+  // Create a new typed array as a view into the combined buffer
+  const {ArrayType, length} = getAccessorArrayTypeAndLength(accessor, bufferView);
+  const byteOffset = bufferView.byteOffset + accessor.byteOffset;
+  return new ArrayType(arrayBuffer, byteOffset, length);
+}
+*/

package/dist/lib/gltf-utils/gltf-attribute-utils.d.ts

@@ -3,3 +3,4 @@ export declare function getGLTFAccessors(attributes: any): {
     [key: string]: GLTFAccessor;
 };
 export declare function getGLTFAccessor(attribute: any): GLTFAccessor;
+//# sourceMappingURL=gltf-attribute-utils.d.ts.map

package/dist/lib/gltf-utils/gltf-attribute-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-attribute-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-attribute-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,qBAAqB,CAAC;AAOtD,wBAAgB,gBAAgB,CAAC,UAAU,KAAA,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAC,CAU1E;AAKD,wBAAgB,eAAe,CAAC,SAAS,KAAA,gBAmBxC"}

package/dist/lib/gltf-utils/gltf-attribute-utils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGLTFAccessor = exports.getGLTFAccessors = void 0;
+// TODO - remove
+const gltf_utils_1 = require("./gltf-utils");
+// Returns a fresh attributes object with glTF-standardized attributes names
+// Attributes that cannot be identified will not be included
+// Removes `indices` if present, as it should be stored separately from the attributes
+function getGLTFAccessors(attributes) {
+    const accessors = {};
+    for (const name in attributes) {
+        const attribute = attributes[name];
+        if (name !== 'indices') {
+            const glTFAccessor = getGLTFAccessor(attribute);
+            accessors[name] = glTFAccessor;
+        }
+    }
+    return accessors;
+}
+exports.getGLTFAccessors = getGLTFAccessors;
+// Fix up a single accessor.
+// Input: typed array or a partial accessor object
+// Return: accessor object
+function getGLTFAccessor(attribute) {
+    const { buffer, size, count } = getAccessorData(attribute);
+    const glTFAccessor = {
+        // glTF Accessor values
+        // TODO: Instead of a bufferView index we could have an actual buffer (typed array)
+        // bufferView: null,
+        // TODO: Deprecate `value` in favor of bufferView?
+        // @ts-ignore
+        value: buffer,
+        size,
+        byteOffset: 0,
+        count,
+        type: (0, gltf_utils_1.getAccessorTypeFromSize)(size),
+        componentType: (0, gltf_utils_1.getComponentTypeFromArray)(buffer)
+    };
+    return glTFAccessor;
+}
+exports.getGLTFAccessor = getGLTFAccessor;
+// export function getGLTFAttribute(data, gltfAttributeName): GLTFAccessor {
+//   return data.attributes[data.glTFAttributeMap[gltfAttributeName]];
+// }
+function getAccessorData(attribute) {
+    let buffer = attribute;
+    let size = 1;
+    let count = 0;
+    if (attribute && attribute.value) {
+        buffer = attribute.value;
+        size = attribute.size || 1;
+    }
+    if (buffer) {
+        if (!ArrayBuffer.isView(buffer)) {
+            buffer = toTypedArray(buffer, Float32Array);
+        }
+        count = buffer.length / size;
+    }
+    return { buffer, size, count };
+}
+// Convert non-typed arrays to arrays of specified format
+function toTypedArray(array, ArrayType, convertTypedArrays = false) {
+    if (!array) {
+        return null;
+    }
+    if (Array.isArray(array)) {
+        return new ArrayType(array);
+    }
+    if (convertTypedArrays && !(array instanceof ArrayType)) {
+        return new ArrayType(array);
+    }
+    return array;
+}

package/dist/lib/gltf-utils/gltf-constants.d.ts

@@ -1,3 +1,4 @@
 export declare function getBytesFromComponentType(componentType: any): any;
 export declare function getSizeFromAccessorType(type: any): any;
 export declare function getGLEnumFromSamplerParameter(parameter: any): any;
+//# sourceMappingURL=gltf-constants.d.ts.map

package/dist/lib/gltf-utils/gltf-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-constants.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-constants.ts"],"names":[],"mappings":"AAqBA,wBAAgB,yBAAyB,CAAC,aAAa,KAAA,OAEtD;AAED,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,OAE3C;AAED,wBAAgB,6BAA6B,CAAC,SAAS,KAAA,OActD"}

package/dist/lib/gltf-utils/gltf-constants.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGLEnumFromSamplerParameter = exports.getSizeFromAccessorType = exports.getBytesFromComponentType = void 0;
+const COMPONENTS = {
+    SCALAR: 1,
+    VEC2: 2,
+    VEC3: 3,
+    VEC4: 4,
+    MAT2: 4,
+    MAT3: 9,
+    MAT4: 16
+};
+const BYTES = {
+    5120: 1,
+    5121: 1,
+    5122: 2,
+    5123: 2,
+    5125: 4,
+    5126: 4 // FLOAT
+};
+// ENUM LOOKUP
+function getBytesFromComponentType(componentType) {
+    return BYTES[componentType];
+}
+exports.getBytesFromComponentType = getBytesFromComponentType;
+function getSizeFromAccessorType(type) {
+    return COMPONENTS[type];
+}
+exports.getSizeFromAccessorType = getSizeFromAccessorType;
+function getGLEnumFromSamplerParameter(parameter) {
+    const GL_TEXTURE_MAG_FILTER = 0x2800;
+    const GL_TEXTURE_MIN_FILTER = 0x2801;
+    const GL_TEXTURE_WRAP_S = 0x2802;
+    const GL_TEXTURE_WRAP_T = 0x2803;
+    const PARAMETER_MAP = {
+        magFilter: GL_TEXTURE_MAG_FILTER,
+        minFilter: GL_TEXTURE_MIN_FILTER,
+        wrapS: GL_TEXTURE_WRAP_S,
+        wrapT: GL_TEXTURE_WRAP_T
+    };
+    return PARAMETER_MAP[parameter];
+}
+exports.getGLEnumFromSamplerParameter = getGLEnumFromSamplerParameter;

package/dist/lib/gltf-utils/gltf-utils.d.ts

@@ -5,3 +5,4 @@ export declare function getAccessorArrayTypeAndLength(accessor: any, bufferView:
     length: number;
     byteLength: number;
 };
+//# sourceMappingURL=gltf-utils.d.ts.map

package/dist/lib/gltf-utils/gltf-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-utils.ts"],"names":[],"mappings":"AAyDA,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,UAG3C;AAED,wBAAgB,yBAAyB,CAAC,UAAU,KAAA,UAMnD;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,KAAA,EAAE,UAAU,KAAA;;;;EAQjE"}

package/dist/lib/gltf-utils/gltf-utils.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccessorArrayTypeAndLength = exports.getComponentTypeFromArray = exports.getAccessorTypeFromSize = void 0;
+const assert_1 = require("../utils/assert");
+const TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];
+const ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
+    [Int8Array, 5120],
+    [Uint8Array, 5121],
+    [Int16Array, 5122],
+    [Uint16Array, 5123],
+    [Uint32Array, 5125],
+    [Float32Array, 5126],
+    [Float64Array, 5130]
+];
+const ARRAY_TO_COMPONENT_TYPE = new Map(ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT);
+const ATTRIBUTE_TYPE_TO_COMPONENTS = {
+    SCALAR: 1,
+    VEC2: 2,
+    VEC3: 3,
+    VEC4: 4,
+    MAT2: 4,
+    MAT3: 9,
+    MAT4: 16
+};
+const ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
+    5120: 1,
+    5121: 1,
+    5122: 2,
+    5123: 2,
+    5125: 4,
+    5126: 4
+};
+const ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
+    5120: Int8Array,
+    5121: Uint8Array,
+    5122: Int16Array,
+    5123: Uint16Array,
+    5125: Uint32Array,
+    5126: Float32Array
+};
+function getAccessorTypeFromSize(size) {
+    const type = TYPES[size - 1];
+    return type || TYPES[0];
+}
+exports.getAccessorTypeFromSize = getAccessorTypeFromSize;
+function getComponentTypeFromArray(typedArray) {
+    const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);
+    if (!componentType) {
+        throw new Error('Illegal typed array');
+    }
+    return componentType;
+}
+exports.getComponentTypeFromArray = getComponentTypeFromArray;
+function getAccessorArrayTypeAndLength(accessor, bufferView) {
+    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
+    const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
+    const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
+    const length = accessor.count * components;
+    const byteLength = accessor.count * components * bytesPerComponent;
+    (0, assert_1.assert)(byteLength >= 0 && byteLength <= bufferView.byteLength);
+    return { ArrayType, length, byteLength };
+}
+exports.getAccessorArrayTypeAndLength = getAccessorArrayTypeAndLength;

package/dist/lib/gltf-utils/resolve-url.d.ts

@@ -1 +1,2 @@
 export declare function resolveUrl(url: any, options: any): any;
+//# sourceMappingURL=resolve-url.d.ts.map

package/dist/lib/gltf-utils/resolve-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-url.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/resolve-url.ts"],"names":[],"mappings":"AAEA,wBAAgB,UAAU,CAAC,GAAG,KAAA,EAAE,OAAO,KAAA,OAWtC"}

package/dist/lib/gltf-utils/resolve-url.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUrl = void 0;
+// Resolves a relative url against a baseUrl
+// If url is absolute, return it unchanged
+function resolveUrl(url, options) {
+    // TODO: Use better logic to handle all protocols plus not delay on data
+    const absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');
+    if (absolute) {
+        return url;
+    }
+    const baseUrl = options.baseUri || options.uri;
+    if (!baseUrl) {
+        throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);
+    }
+    return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;
+}
+exports.resolveUrl = resolveUrl;

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

@@ -5,3 +5,4 @@ export declare type GLBParseOptions = {
 };
 export declare function isGLB(arrayBuffer: ArrayBuffer, byteOffset?: number, options?: GLBParseOptions): boolean;
 export default function parseGLBSync(glb: GLB, arrayBuffer: ArrayBuffer, byteOffset?: number, options?: GLBParseOptions): number;
+//# sourceMappingURL=parse-glb.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-glb.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-glb.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oBAAoB,CAAC;AAG5C,oBAAY,eAAe,GAAG;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAyBF,wBAAgB,KAAK,CACnB,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,MAAU,EACtB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAMT;AAED,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,MAAU,EACtB,OAAO,GAAE,eAAoB,UAqC9B"}

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

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGLB = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const MAGIC_glTF = 0x676c5446; // glTF in Big-Endian ASCII
+const GLB_FILE_HEADER_SIZE = 12;
+const GLB_CHUNK_HEADER_SIZE = 8;
+const GLB_CHUNK_TYPE_JSON = 0x4e4f534a;
+const GLB_CHUNK_TYPE_BIN = 0x004e4942;
+const GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0; // DEPRECATED - Backward compatibility for old xviz files
+const GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1; // DEPRECATED - Backward compatibility for old xviz files
+const GLB_V1_CONTENT_FORMAT_JSON = 0x0;
+const LE = true; // Binary GLTF is little endian.
+function getMagicString(dataView, byteOffset = 0) {
+    return `\
+${String.fromCharCode(dataView.getUint8(byteOffset + 0))}\
+${String.fromCharCode(dataView.getUint8(byteOffset + 1))}\
+${String.fromCharCode(dataView.getUint8(byteOffset + 2))}\
+${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;
+}
+// Check if a data view is a GLB
+function isGLB(arrayBuffer, byteOffset = 0, options = {}) {
+    const dataView = new DataView(arrayBuffer);
+    // Check that GLB Header starts with the magic number
+    const { magic = MAGIC_glTF } = options;
+    const magic1 = dataView.getUint32(byteOffset, false);
+    return magic1 === magic || magic1 === MAGIC_glTF;
+}
+exports.isGLB = isGLB;
+function parseGLBSync(glb, arrayBuffer, byteOffset = 0, options = {}) {
+    // Check that GLB Header starts with the magic number
+    const dataView = new DataView(arrayBuffer);
+    // Compare format with GLBLoader documentation
+    const type = getMagicString(dataView, byteOffset + 0);
+    const version = dataView.getUint32(byteOffset + 4, LE); // Version 2 of binary glTF container format
+    const byteLength = dataView.getUint32(byteOffset + 8, LE); // Total byte length of binary file
+    Object.assign(glb, {
+        // Put less important stuff in a header, to avoid clutter
+        header: {
+            byteOffset,
+            byteLength,
+            hasBinChunk: false
+        },
+        type,
+        version,
+        json: {},
+        binChunks: []
+    });
+    byteOffset += GLB_FILE_HEADER_SIZE;
+    switch (glb.version) {
+        case 1:
+            // eslint-disable-next-line
+            return parseGLBV1(glb, dataView, byteOffset);
+        case 2:
+            // eslint-disable-next-line
+            return parseGLBV2(glb, dataView, byteOffset, (options = {}));
+        default:
+            throw new Error(`Invalid GLB version ${glb.version}. Only supports v1 and v2.`);
+    }
+}
+exports.default = parseGLBSync;
+function parseGLBV1(glb, dataView, byteOffset) {
+    // Sanity: ensure file is big enough to hold at least the headers
+    (0, loader_utils_1.assert)(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+    // Explanation of GLB structure:
+    // https://cloud.githubusercontent.com/assets/3479527/22600725/36b87122-ea55-11e6-9d40-6fd42819fcab.png
+    const contentLength = dataView.getUint32(byteOffset + 0, LE); // Byte length of chunk
+    const contentFormat = dataView.getUint32(byteOffset + 4, LE); // Chunk format as uint32
+    byteOffset += GLB_CHUNK_HEADER_SIZE;
+    // GLB v1 only supports a single chunk type
+    (0, loader_utils_1.assert)(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);
+    parseJSONChunk(glb, dataView, byteOffset, contentLength);
+    // No need to call the function padToBytes() from parseJSONChunk()
+    byteOffset += contentLength;
+    byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);
+    return byteOffset;
+}
+function parseGLBV2(glb, dataView, byteOffset, options) {
+    // Sanity: ensure file is big enough to hold at least the first chunk header
+    (0, loader_utils_1.assert)(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+    parseGLBChunksSync(glb, dataView, byteOffset, options);
+    return byteOffset + glb.header.byteLength;
+}
+function parseGLBChunksSync(glb, dataView, byteOffset, options) {
+    // Per spec we must iterate over chunks, ignoring all except JSON and BIN
+    // Iterate as long as there is space left for another chunk header
+    while (byteOffset + 8 <= glb.header.byteLength) {
+        const chunkLength = dataView.getUint32(byteOffset + 0, LE); // Byte length of chunk
+        const chunkFormat = dataView.getUint32(byteOffset + 4, LE); // Chunk format as uint32
+        byteOffset += GLB_CHUNK_HEADER_SIZE;
+        // Per spec we must iterate over chunks, ignoring all except JSON and BIN
+        switch (chunkFormat) {
+            case GLB_CHUNK_TYPE_JSON:
+                parseJSONChunk(glb, dataView, byteOffset, chunkLength);
+                break;
+            case GLB_CHUNK_TYPE_BIN:
+                parseBINChunk(glb, dataView, byteOffset, chunkLength);
+                break;
+            // Backward compatibility for very old xviz files
+            case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:
+                if (!options.strict) {
+                    parseJSONChunk(glb, dataView, byteOffset, chunkLength);
+                }
+                break;
+            case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:
+                if (!options.strict) {
+                    parseBINChunk(glb, dataView, byteOffset, chunkLength);
+                }
+                break;
+            default:
+                // Ignore, per spec
+                // console.warn(`Unknown GLB chunk type`); // eslint-disable-line
+                break;
+        }
+        byteOffset += (0, loader_utils_1.padToNBytes)(chunkLength, 4);
+    }
+    return byteOffset;
+}
+// Parse a GLB JSON chunk
+function parseJSONChunk(glb, dataView, byteOffset, chunkLength) {
+    // 1. Create a "view" of the binary encoded JSON data inside the GLB
+    const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);
+    // 2. Decode the JSON binary array into clear text
+    const textDecoder = new TextDecoder('utf8');
+    const jsonText = textDecoder.decode(jsonChunk);
+    // 3. Parse the JSON text into a JavaScript data structure
+    glb.json = JSON.parse(jsonText);
+    return (0, loader_utils_1.padToNBytes)(chunkLength, 4);
+}
+// Parse a GLB BIN chunk
+function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
+    // Note: BIN chunk can be optional
+    glb.header.hasBinChunk = true;
+    glb.binChunks.push({
+        byteOffset,
+        byteLength: chunkLength,
+        arrayBuffer: dataView.buffer
+        // TODO - copy, or create typed array view?
+    });
+    return (0, loader_utils_1.padToNBytes)(chunkLength, 4);
+}

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

@@ -10,4 +10,5 @@ export declare type GLTFParseOptions = {
     excludeExtensions?: string[];
 };
 export declare function isGLTF(arrayBuffer: any, options?: any): boolean;
-export declare function parseGLTF(gltf: GLTFWithBuffers, arrayBufferOrString: any, byteOffset: number | undefined, options: GLTFLoaderOptions, context: LoaderContext): Promise<any>;
+export declare function parseGLTF(gltf: GLTFWithBuffers, arrayBufferOrString: any, byteOffset: number | undefined, options: GLTFLoaderOptions, context: LoaderContext): Promise<Record<string, any>>;
+//# sourceMappingURL=parse-gltf.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-gltf.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-gltf.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE5D,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAEzD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,qBAAqB,CAAC;AAYzD,oBAAY,gBAAgB,GAAG;IAC7B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAMF,wBAAgB,MAAM,CAAC,WAAW,KAAA,EAAE,OAAO,CAAC,KAAA,GAAG,OAAO,CAGrD;AAED,wBAAsB,SAAS,CAC7B,IAAI,EAAE,eAAe,EACrB,mBAAmB,KAAA,EACnB,UAAU,oBAAI,EACd,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,aAAa,gCA4BvB"}