@babylonjs/viewer 7.40.2-alpha → 7.40.2

package/dist/chunks/KHR_draco_mesh_compression-Bn3cig1r.esm.js

@@ -1,617 +0,0 @@
-import { T as Tools, w as Geometry, V as VertexBuffer, x as VertexData, L as Logger, aP as unregisterGLTFExtension, aQ as registerGLTFExtension } from './index-DnSap2FI.esm.js';
-import { A as AutoReleaseWorkerPool } from './workerPool-BUOov2K1.esm.js';
-import { G as GLTFLoader, A as ArrayItem, L as LoadBoundingInfoFromPositionAccessor } from './glTFLoader-C3ib4SHM.esm.js';
-import './rawTexture-CBbxz3pc.esm.js';
-import './assetContainer-nATkXNwM.esm.js';
-import './glTFLoaderAnimation-CIZW3HpB.esm.js';
-
-/**
- * @internal
- */
-function decodeMesh(decoderModule /*DecoderModule*/, data, attributes, onIndicesData, onAttributeData) {
-    let decoder = null;
-    let buffer = null;
-    let geometry = null;
-    try {
-        decoder = new decoderModule.Decoder();
-        buffer = new decoderModule.DecoderBuffer();
-        buffer.Init(data, data.byteLength);
-        let status;
-        const type = decoder.GetEncodedGeometryType(buffer);
-        switch (type) {
-            case decoderModule.TRIANGULAR_MESH: {
-                const mesh = new decoderModule.Mesh();
-                status = decoder.DecodeBufferToMesh(buffer, mesh);
-                if (!status.ok() || mesh.ptr === 0) {
-                    throw new Error(status.error_msg());
-                }
-                const numFaces = mesh.num_faces();
-                const numIndices = numFaces * 3;
-                const byteLength = numIndices * 4;
-                const ptr = decoderModule._malloc(byteLength);
-                try {
-                    decoder.GetTrianglesUInt32Array(mesh, byteLength, ptr);
-                    const indices = new Uint32Array(numIndices);
-                    indices.set(new Uint32Array(decoderModule.HEAPF32.buffer, ptr, numIndices));
-                    onIndicesData(indices);
-                }
-                finally {
-                    decoderModule._free(ptr);
-                }
-                geometry = mesh;
-                break;
-            }
-            case decoderModule.POINT_CLOUD: {
-                const pointCloud = new decoderModule.PointCloud();
-                status = decoder.DecodeBufferToPointCloud(buffer, pointCloud);
-                if (!status.ok() || !pointCloud.ptr) {
-                    throw new Error(status.error_msg());
-                }
-                geometry = pointCloud;
-                break;
-            }
-            default: {
-                throw new Error(`Invalid geometry type ${type}`);
-            }
-        }
-        const numPoints = geometry.num_points();
-        const processAttribute = (decoder, geometry, kind, attribute) => {
-            const dataType = attribute.data_type();
-            const numComponents = attribute.num_components();
-            const normalized = attribute.normalized();
-            const byteStride = attribute.byte_stride();
-            const byteOffset = attribute.byte_offset();
-            const dataTypeInfo = {
-                [decoderModule.DT_FLOAT32]: { typedArrayConstructor: Float32Array, heap: decoderModule.HEAPF32 },
-                [decoderModule.DT_INT8]: { typedArrayConstructor: Int8Array, heap: decoderModule.HEAP8 },
-                [decoderModule.DT_INT16]: { typedArrayConstructor: Int16Array, heap: decoderModule.HEAP16 },
-                [decoderModule.DT_INT32]: { typedArrayConstructor: Int32Array, heap: decoderModule.HEAP32 },
-                [decoderModule.DT_UINT8]: { typedArrayConstructor: Uint8Array, heap: decoderModule.HEAPU8 },
-                [decoderModule.DT_UINT16]: { typedArrayConstructor: Uint16Array, heap: decoderModule.HEAPU16 },
-                [decoderModule.DT_UINT32]: { typedArrayConstructor: Uint32Array, heap: decoderModule.HEAPU32 },
-            };
-            const info = dataTypeInfo[dataType];
-            if (!info) {
-                throw new Error(`Invalid data type ${dataType}`);
-            }
-            const numValues = numPoints * numComponents;
-            const byteLength = numValues * info.typedArrayConstructor.BYTES_PER_ELEMENT;
-            const ptr = decoderModule._malloc(byteLength);
-            try {
-                decoder.GetAttributeDataArrayForAllPoints(geometry, attribute, dataType, byteLength, ptr);
-                const data = new info.typedArrayConstructor(info.heap.buffer, ptr, numValues);
-                onAttributeData(kind, data.slice(), numComponents, byteOffset, byteStride, normalized);
-            }
-            finally {
-                decoderModule._free(ptr);
-            }
-        };
-        if (attributes) {
-            for (const kind in attributes) {
-                const id = attributes[kind];
-                const attribute = decoder.GetAttributeByUniqueId(geometry, id);
-                processAttribute(decoder, geometry, kind, attribute);
-            }
-        }
-        else {
-            const dracoAttributeTypes = {
-                position: decoderModule.POSITION,
-                normal: decoderModule.NORMAL,
-                color: decoderModule.COLOR,
-                uv: decoderModule.TEX_COORD,
-            };
-            for (const kind in dracoAttributeTypes) {
-                const id = decoder.GetAttributeId(geometry, dracoAttributeTypes[kind]);
-                if (id !== -1) {
-                    const attribute = decoder.GetAttribute(geometry, id);
-                    processAttribute(decoder, geometry, kind, attribute);
-                }
-            }
-        }
-        return numPoints;
-    }
-    finally {
-        if (geometry) {
-            decoderModule.destroy(geometry);
-        }
-        if (buffer) {
-            decoderModule.destroy(buffer);
-        }
-        if (decoder) {
-            decoderModule.destroy(decoder);
-        }
-    }
-}
-/**
- * The worker function that gets converted to a blob url to pass into a worker.
- * To be used if a developer wants to create their own worker instance and inject it instead of using the default worker.
- */
-function workerFunction() {
-    let decoderPromise;
-    onmessage = (event) => {
-        const message = event.data;
-        switch (message.id) {
-            case "init": {
-                const decoder = message.decoder;
-                // if URL is provided then load the script. Otherwise expect the script to be loaded already
-                if (decoder.url) {
-                    importScripts(decoder.url);
-                }
-                const initDecoderObject = decoder.wasmBinary ? { wasmBinary: decoder.wasmBinary } : {};
-                decoderPromise = DracoDecoderModule(initDecoderObject);
-                postMessage({ id: "initDone" });
-                break;
-            }
-            case "decodeMesh": {
-                if (!decoderPromise) {
-                    throw new Error("Draco decoder module is not available");
-                }
-                decoderPromise.then((decoder) => {
-                    const numPoints = decodeMesh(decoder, message.dataView, message.attributes, (indices) => {
-                        postMessage({ id: "indices", data: indices }, [indices.buffer]);
-                    }, (kind, data, size, offset, stride, normalized) => {
-                        postMessage({ id: "attribute", kind, data, size, byteOffset: offset, byteStride: stride, normalized }, [data.buffer]);
-                    });
-                    postMessage({ id: "decodeMeshDone", totalVertices: numPoints });
-                });
-                break;
-            }
-        }
-    };
-}
-/**
- * Initializes a worker that was created for the draco agent pool
- * @param worker  The worker to initialize
- * @param decoderWasmBinary The wasm binary to load into the worker
- * @param moduleUrl The url to the draco decoder module (optional)
- * @returns A promise that resolves when the worker is initialized
- */
-function initializeWebWorker(worker, decoderWasmBinary, moduleUrl) {
-    return new Promise((resolve, reject) => {
-        const onError = (error) => {
-            worker.removeEventListener("error", onError);
-            worker.removeEventListener("message", onMessage);
-            reject(error);
-        };
-        const onMessage = (event) => {
-            if (event.data.id === "initDone") {
-                worker.removeEventListener("error", onError);
-                worker.removeEventListener("message", onMessage);
-                resolve(worker);
-            }
-        };
-        worker.addEventListener("error", onError);
-        worker.addEventListener("message", onMessage);
-        if (!decoderWasmBinary) {
-            worker.postMessage({
-                id: "init",
-                decoder: {
-                    url: moduleUrl,
-                },
-            });
-        }
-        else {
-            // clone the array buffer to make it transferable
-            const clone = decoderWasmBinary.slice(0);
-            worker.postMessage({
-                id: "init",
-                decoder: {
-                    url: moduleUrl,
-                    wasmBinary: clone,
-                },
-            }, [clone]);
-        }
-        // note: no transfer list as the ArrayBuffer is shared across main thread and pool workers
-    });
-}
-
-function createDecoderAsync(wasmBinary, jsModule) {
-    return new Promise((resolve) => {
-        (jsModule || DracoDecoderModule)({ wasmBinary }).then((module) => {
-            resolve({ module });
-        });
-    });
-}
-/**
- * Draco compression (https://google.github.io/draco/)
- *
- * This class wraps the Draco module.
- *
- * **Encoder**
- *
- * The encoder is not currently implemented.
- *
- * **Decoder**
- *
- * By default, the configuration points to a copy of the Draco decoder files for glTF from the babylon.js preview cdn https://preview.babylonjs.com/draco_wasm_wrapper_gltf.js.
- *
- * To update the configuration, use the following code:
- * ```javascript
- *     DracoCompression.Configuration = {
- *         decoder: {
- *             wasmUrl: "<url to the WebAssembly library>",
- *             wasmBinaryUrl: "<url to the WebAssembly binary>",
- *             fallbackUrl: "<url to the fallback JavaScript library>",
- *         }
- *     };
- * ```
- *
- * Draco has two versions, one for WebAssembly and one for JavaScript. The decoder configuration can be set to only support WebAssembly or only support the JavaScript version.
- * Decoding will automatically fallback to the JavaScript version if WebAssembly version is not configured or if WebAssembly is not supported by the browser.
- * Use `DracoCompression.DecoderAvailable` to determine if the decoder configuration is available for the current context.
- *
- * To decode Draco compressed data, get the default DracoCompression object and call decodeMeshToGeometryAsync:
- * ```javascript
- *     var geometry = await DracoCompression.Default.decodeMeshToGeometryAsync(data);
- * ```
- *
- * @see https://playground.babylonjs.com/#DMZIBD#0
- */
-class DracoCompression {
-    /**
-     * Returns true if the decoder configuration is available.
-     */
-    static get DecoderAvailable() {
-        const decoder = DracoCompression.Configuration.decoder;
-        return !!((decoder.wasmUrl && decoder.wasmBinaryUrl && typeof WebAssembly === "object") || decoder.fallbackUrl);
-    }
-    static GetDefaultNumWorkers() {
-        if (typeof navigator !== "object" || !navigator.hardwareConcurrency) {
-            return 1;
-        }
-        // Use 50% of the available logical processors but capped at 4.
-        return Math.min(Math.floor(navigator.hardwareConcurrency * 0.5), 4);
-    }
-    /**
-     * Default instance for the draco compression object.
-     */
-    static get Default() {
-        if (!DracoCompression._Default) {
-            DracoCompression._Default = new DracoCompression();
-        }
-        return DracoCompression._Default;
-    }
-    /**
-     * Reset the default draco compression object to null and disposing the removed default instance.
-     * Note that if the workerPool is a member of the static Configuration object it is recommended not to run dispose,
-     * unless the static worker pool is no longer needed.
-     * @param skipDispose set to true to not dispose the removed default instance
-     */
-    static ResetDefault(skipDispose) {
-        if (DracoCompression._Default) {
-            if (!skipDispose) {
-                DracoCompression._Default.dispose();
-            }
-            DracoCompression._Default = null;
-        }
-    }
-    /**
-     * Constructor
-     * @param numWorkers The number of workers for async operations Or an options object. Specify `0` to disable web workers and run synchronously in the current context.
-     */
-    constructor(numWorkers = DracoCompression.DefaultNumWorkers) {
-        const decoder = DracoCompression.Configuration.decoder;
-        // check if the decoder binary and worker pool was injected
-        // Note - it is expected that the developer checked if WebWorker, WebAssembly and the URL object are available
-        if (decoder.workerPool || (typeof numWorkers === "object" && numWorkers.workerPool)) {
-            // set the promise accordingly
-            this._workerPoolPromise = Promise.resolve(decoder.workerPool || numWorkers.workerPool);
-        }
-        else {
-            // to avoid making big changes to the decider, if wasmBinary is provided use it in the wasmBinaryPromise
-            const wasmBinaryProvided = decoder.wasmBinary || (typeof numWorkers === "object" && numWorkers.wasmBinary);
-            const numberOfWorkers = typeof numWorkers === "number" ? numWorkers : numWorkers.numWorkers;
-            const useWorkers = numberOfWorkers && typeof Worker === "function" && typeof URL === "function";
-            const urlNeeded = useWorkers || (!useWorkers && !decoder.jsModule);
-            // code maintained here for back-compat with no changes
-            const decoderInfo = decoder.wasmUrl && decoder.wasmBinaryUrl && typeof WebAssembly === "object"
-                ? {
-                    url: urlNeeded ? Tools.GetBabylonScriptURL(decoder.wasmUrl, true) : "",
-                    wasmBinaryPromise: wasmBinaryProvided ? Promise.resolve(wasmBinaryProvided) : Tools.LoadFileAsync(Tools.GetBabylonScriptURL(decoder.wasmBinaryUrl, true)),
-                }
-                : {
-                    url: urlNeeded ? Tools.GetBabylonScriptURL(decoder.fallbackUrl) : "",
-                    wasmBinaryPromise: Promise.resolve(undefined),
-                };
-            if (useWorkers) {
-                this._workerPoolPromise = decoderInfo.wasmBinaryPromise.then((decoderWasmBinary) => {
-                    const workerContent = `${decodeMesh}(${workerFunction})()`;
-                    const workerBlobUrl = URL.createObjectURL(new Blob([workerContent], { type: "application/javascript" }));
-                    return new AutoReleaseWorkerPool(numberOfWorkers, () => {
-                        const worker = new Worker(workerBlobUrl);
-                        return initializeWebWorker(worker, decoderWasmBinary, decoderInfo.url);
-                    });
-                });
-            }
-            else {
-                this._decoderModulePromise = decoderInfo.wasmBinaryPromise.then(async (decoderWasmBinary) => {
-                    if (typeof DracoDecoderModule === "undefined") {
-                        if (!decoder.jsModule) {
-                            if (!decoderInfo.url) {
-                                throw new Error("Draco decoder module is not available");
-                            }
-                            await Tools.LoadBabylonScriptAsync(decoderInfo.url);
-                        }
-                    }
-                    return await createDecoderAsync(decoderWasmBinary, decoder.jsModule);
-                });
-            }
-        }
-    }
-    /**
-     * Stop all async operations and release resources.
-     */
-    dispose() {
-        if (this._workerPoolPromise) {
-            this._workerPoolPromise.then((workerPool) => {
-                workerPool.dispose();
-            });
-        }
-        delete this._workerPoolPromise;
-        delete this._decoderModulePromise;
-    }
-    /**
-     * Returns a promise that resolves when ready. Call this manually to ensure draco compression is ready before use.
-     * @returns a promise that resolves when ready
-     */
-    async whenReadyAsync() {
-        if (this._workerPoolPromise) {
-            await this._workerPoolPromise;
-            return;
-        }
-        if (this._decoderModulePromise) {
-            await this._decoderModulePromise;
-            return;
-        }
-    }
-    /**
-     * Decode Draco compressed mesh data to mesh data.
-     * @param data The ArrayBuffer or ArrayBufferView for the Draco compression data
-     * @param attributes A map of attributes from vertex buffer kinds to Draco unique ids
-     * @param gltfNormalizedOverride A map of attributes from vertex buffer kinds to normalized flags to override the Draco normalization
-     * @returns A promise that resolves with the decoded mesh data
-     */
-    decodeMeshToMeshDataAsync(data, attributes, gltfNormalizedOverride) {
-        const dataView = data instanceof ArrayBuffer ? new Int8Array(data) : new Int8Array(data.buffer, data.byteOffset, data.byteLength);
-        const applyGltfNormalizedOverride = (kind, normalized) => {
-            if (gltfNormalizedOverride && gltfNormalizedOverride[kind] !== undefined) {
-                if (normalized !== gltfNormalizedOverride[kind]) {
-                    Logger.Warn(`Normalized flag from Draco data (${normalized}) does not match normalized flag from glTF accessor (${gltfNormalizedOverride[kind]}). Using flag from glTF accessor.`);
-                }
-                return gltfNormalizedOverride[kind];
-            }
-            else {
-                return normalized;
-            }
-        };
-        if (this._workerPoolPromise) {
-            return this._workerPoolPromise.then((workerPool) => {
-                return new Promise((resolve, reject) => {
-                    workerPool.push((worker, onComplete) => {
-                        let resultIndices = null;
-                        const resultAttributes = [];
-                        const onError = (error) => {
-                            worker.removeEventListener("error", onError);
-                            worker.removeEventListener("message", onMessage);
-                            reject(error);
-                            onComplete();
-                        };
-                        const onMessage = (event) => {
-                            const message = event.data;
-                            switch (message.id) {
-                                case "decodeMeshDone": {
-                                    worker.removeEventListener("error", onError);
-                                    worker.removeEventListener("message", onMessage);
-                                    resolve({ indices: resultIndices, attributes: resultAttributes, totalVertices: message.totalVertices });
-                                    onComplete();
-                                    break;
-                                }
-                                case "indices": {
-                                    resultIndices = message.data;
-                                    break;
-                                }
-                                case "attribute": {
-                                    resultAttributes.push({
-                                        kind: message.kind,
-                                        data: message.data,
-                                        size: message.size,
-                                        byteOffset: message.byteOffset,
-                                        byteStride: message.byteStride,
-                                        normalized: applyGltfNormalizedOverride(message.kind, message.normalized),
-                                    });
-                                    break;
-                                }
-                            }
-                        };
-                        worker.addEventListener("error", onError);
-                        worker.addEventListener("message", onMessage);
-                        const dataViewCopy = dataView.slice();
-                        worker.postMessage({ id: "decodeMesh", dataView: dataViewCopy, attributes: attributes }, [dataViewCopy.buffer]);
-                    });
-                });
-            });
-        }
-        if (this._decoderModulePromise) {
-            return this._decoderModulePromise.then((decoder) => {
-                let resultIndices = null;
-                const resultAttributes = [];
-                const numPoints = decodeMesh(decoder.module, dataView, attributes, (indices) => {
-                    resultIndices = indices;
-                }, (kind, data, size, byteOffset, byteStride, normalized) => {
-                    resultAttributes.push({
-                        kind,
-                        data,
-                        size,
-                        byteOffset,
-                        byteStride,
-                        normalized,
-                    });
-                });
-                return { indices: resultIndices, attributes: resultAttributes, totalVertices: numPoints };
-            });
-        }
-        throw new Error("Draco decoder module is not available");
-    }
-    /**
-     * Decode Draco compressed mesh data to Babylon geometry.
-     * @param name The name to use when creating the geometry
-     * @param scene The scene to use when creating the geometry
-     * @param data The ArrayBuffer or ArrayBufferView for the Draco compression data
-     * @param attributes A map of attributes from vertex buffer kinds to Draco unique ids
-     * @returns A promise that resolves with the decoded geometry
-     */
-    async decodeMeshToGeometryAsync(name, scene, data, attributes) {
-        const meshData = await this.decodeMeshToMeshDataAsync(data, attributes);
-        const geometry = new Geometry(name, scene);
-        if (meshData.indices) {
-            geometry.setIndices(meshData.indices);
-        }
-        for (const attribute of meshData.attributes) {
-            geometry.setVerticesBuffer(new VertexBuffer(scene.getEngine(), attribute.data, attribute.kind, false, undefined, attribute.byteStride, undefined, attribute.byteOffset, attribute.size, undefined, attribute.normalized, true), meshData.totalVertices);
-        }
-        return geometry;
-    }
-    /** @internal */
-    async _decodeMeshToGeometryForGltfAsync(name, scene, data, attributes, gltfNormalizedOverride, boundingInfo) {
-        const meshData = await this.decodeMeshToMeshDataAsync(data, attributes, gltfNormalizedOverride);
-        const geometry = new Geometry(name, scene);
-        if (boundingInfo) {
-            geometry._boundingInfo = boundingInfo;
-            geometry.useBoundingInfoFromGeometry = true;
-        }
-        if (meshData.indices) {
-            geometry.setIndices(meshData.indices);
-        }
-        for (const attribute of meshData.attributes) {
-            geometry.setVerticesBuffer(new VertexBuffer(scene.getEngine(), attribute.data, attribute.kind, false, undefined, attribute.byteStride, undefined, attribute.byteOffset, attribute.size, undefined, attribute.normalized, true), meshData.totalVertices);
-        }
-        return geometry;
-    }
-    /**
-     * Decode Draco compressed mesh data to Babylon vertex data.
-     * @param data The ArrayBuffer or ArrayBufferView for the Draco compression data
-     * @param attributes A map of attributes from vertex buffer kinds to Draco unique ids
-     * @returns A promise that resolves with the decoded vertex data
-     * @deprecated Use {@link decodeMeshToGeometryAsync} for better performance in some cases
-     */
-    async decodeMeshAsync(data, attributes) {
-        const meshData = await this.decodeMeshToMeshDataAsync(data, attributes);
-        const vertexData = new VertexData();
-        if (meshData.indices) {
-            vertexData.indices = meshData.indices;
-        }
-        for (const attribute of meshData.attributes) {
-            const floatData = VertexBuffer.GetFloatData(attribute.data, attribute.size, VertexBuffer.GetDataType(attribute.data), attribute.byteOffset, attribute.byteStride, attribute.normalized, meshData.totalVertices);
-            vertexData.set(floatData, attribute.kind);
-        }
-        return vertexData;
-    }
-}
-/**
- * The configuration. Defaults to the following urls:
- * - wasmUrl: "https://cdn.babylonjs.com/draco_wasm_wrapper_gltf.js"
- * - wasmBinaryUrl: "https://cdn.babylonjs.com/draco_decoder_gltf.wasm"
- * - fallbackUrl: "https://cdn.babylonjs.com/draco_decoder_gltf.js"
- */
-DracoCompression.Configuration = {
-    decoder: {
-        wasmUrl: `${Tools._DefaultCdnUrl}/draco_wasm_wrapper_gltf.js`,
-        wasmBinaryUrl: `${Tools._DefaultCdnUrl}/draco_decoder_gltf.wasm`,
-        fallbackUrl: `${Tools._DefaultCdnUrl}/draco_decoder_gltf.js`,
-    },
-};
-/**
- * Default number of workers to create when creating the draco compression object.
- */
-DracoCompression.DefaultNumWorkers = DracoCompression.GetDefaultNumWorkers();
-DracoCompression._Default = null;
-
-const NAME = "KHR_draco_mesh_compression";
-/**
- * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md)
- */
-// eslint-disable-next-line @typescript-eslint/naming-convention
-class KHR_draco_mesh_compression {
-    /**
-     * @internal
-     */
-    constructor(loader) {
-        /**
-         * The name of this extension.
-         */
-        this.name = NAME;
-        /**
-         * Defines whether to use the normalized flag from the glTF accessor instead of the Draco data. Defaults to true.
-         */
-        this.useNormalizedFlagFromAccessor = true;
-        this._loader = loader;
-        this.enabled = DracoCompression.DecoderAvailable && this._loader.isExtensionUsed(NAME);
-    }
-    /** @internal */
-    dispose() {
-        delete this.dracoCompression;
-        this._loader = null;
-    }
-    /**
-     * @internal
-     */
-    _loadVertexDataAsync(context, primitive, babylonMesh) {
-        return GLTFLoader.LoadExtensionAsync(context, primitive, this.name, (extensionContext, extension) => {
-            if (primitive.mode != undefined) {
-                if (primitive.mode !== 4 /* MeshPrimitiveMode.TRIANGLES */ && primitive.mode !== 5 /* MeshPrimitiveMode.TRIANGLE_STRIP */) {
-                    throw new Error(`${context}: Unsupported mode ${primitive.mode}`);
-                }
-            }
-            const attributes = {};
-            const normalized = {};
-            const loadAttribute = (name, kind) => {
-                const uniqueId = extension.attributes[name];
-                if (uniqueId == undefined) {
-                    return;
-                }
-                babylonMesh._delayInfo = babylonMesh._delayInfo || [];
-                if (babylonMesh._delayInfo.indexOf(kind) === -1) {
-                    babylonMesh._delayInfo.push(kind);
-                }
-                attributes[kind] = uniqueId;
-                if (this.useNormalizedFlagFromAccessor) {
-                    const accessor = ArrayItem.TryGet(this._loader.gltf.accessors, primitive.attributes[name]);
-                    if (accessor) {
-                        normalized[kind] = accessor.normalized || false;
-                    }
-                }
-            };
-            loadAttribute("POSITION", VertexBuffer.PositionKind);
-            loadAttribute("NORMAL", VertexBuffer.NormalKind);
-            loadAttribute("TANGENT", VertexBuffer.TangentKind);
-            loadAttribute("TEXCOORD_0", VertexBuffer.UVKind);
-            loadAttribute("TEXCOORD_1", VertexBuffer.UV2Kind);
-            loadAttribute("TEXCOORD_2", VertexBuffer.UV3Kind);
-            loadAttribute("TEXCOORD_3", VertexBuffer.UV4Kind);
-            loadAttribute("TEXCOORD_4", VertexBuffer.UV5Kind);
-            loadAttribute("TEXCOORD_5", VertexBuffer.UV6Kind);
-            loadAttribute("JOINTS_0", VertexBuffer.MatricesIndicesKind);
-            loadAttribute("WEIGHTS_0", VertexBuffer.MatricesWeightsKind);
-            loadAttribute("COLOR_0", VertexBuffer.ColorKind);
-            const bufferView = ArrayItem.Get(extensionContext, this._loader.gltf.bufferViews, extension.bufferView);
-            if (!bufferView._dracoBabylonGeometry) {
-                bufferView._dracoBabylonGeometry = this._loader.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {
-                    const dracoCompression = this.dracoCompression || DracoCompression.Default;
-                    const positionAccessor = ArrayItem.TryGet(this._loader.gltf.accessors, primitive.attributes["POSITION"]);
-                    const babylonBoundingInfo = !this._loader.parent.alwaysComputeBoundingBox && !babylonMesh.skeleton && positionAccessor ? LoadBoundingInfoFromPositionAccessor(positionAccessor) : null;
-                    return dracoCompression
-                        ._decodeMeshToGeometryForGltfAsync(babylonMesh.name, this._loader.babylonScene, data, attributes, normalized, babylonBoundingInfo)
-                        .catch((error) => {
-                        throw new Error(`${context}: ${error.message}`);
-                    });
-                });
-            }
-            return bufferView._dracoBabylonGeometry;
-        });
-    }
-}
-unregisterGLTFExtension(NAME);
-registerGLTFExtension(NAME, true, (loader) => new KHR_draco_mesh_compression(loader));
-
-export { KHR_draco_mesh_compression };
-//# sourceMappingURL=KHR_draco_mesh_compression-Bn3cig1r.esm.js.map