@babylonjs/viewer 7.40.4 → 7.41.0-alpha

package/dist/chunks/KHR_draco_mesh_compression-DU2Rk2nj.esm.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KHR_draco_mesh_compression-DU2Rk2nj.esm.min.js","sources":["../../../../../dev/core/dist/Meshes/Compression/dracoCompressionWorker.js","../../../../../dev/core/dist/Meshes/Compression/dracoCodec.js","../../../../../dev/core/dist/Meshes/Compression/dracoDecoder.js","../../../../../dev/loaders/dist/glTF/2.0/Extensions/KHR_draco_mesh_compression.js"],"sourcesContent":["/**\n * @internal\n */\nexport function decodeMesh(decoderModule /*DecoderModule*/, data, attributes, onIndicesData, onAttributeData) {\n    let decoder = null;\n    let buffer = null;\n    let geometry = null;\n    try {\n        decoder = new decoderModule.Decoder();\n        buffer = new decoderModule.DecoderBuffer();\n        buffer.Init(data, data.byteLength);\n        let status;\n        const type = decoder.GetEncodedGeometryType(buffer);\n        switch (type) {\n            case decoderModule.TRIANGULAR_MESH: {\n                const mesh = new decoderModule.Mesh();\n                status = decoder.DecodeBufferToMesh(buffer, mesh);\n                if (!status.ok() || mesh.ptr === 0) {\n                    throw new Error(status.error_msg());\n                }\n                const numFaces = mesh.num_faces();\n                const numIndices = numFaces * 3;\n                const byteLength = numIndices * 4;\n                const ptr = decoderModule._malloc(byteLength);\n                try {\n                    decoder.GetTrianglesUInt32Array(mesh, byteLength, ptr);\n                    const indices = new Uint32Array(numIndices);\n                    indices.set(new Uint32Array(decoderModule.HEAPF32.buffer, ptr, numIndices));\n                    onIndicesData(indices);\n                }\n                finally {\n                    decoderModule._free(ptr);\n                }\n                geometry = mesh;\n                break;\n            }\n            case decoderModule.POINT_CLOUD: {\n                const pointCloud = new decoderModule.PointCloud();\n                status = decoder.DecodeBufferToPointCloud(buffer, pointCloud);\n                if (!status.ok() || !pointCloud.ptr) {\n                    throw new Error(status.error_msg());\n                }\n                geometry = pointCloud;\n                break;\n            }\n            default: {\n                throw new Error(`Invalid geometry type ${type}`);\n            }\n        }\n        const numPoints = geometry.num_points();\n        const processAttribute = (decoder, geometry, kind, attribute) => {\n            const dataType = attribute.data_type();\n            const numComponents = attribute.num_components();\n            const normalized = attribute.normalized();\n            const byteStride = attribute.byte_stride();\n            const byteOffset = attribute.byte_offset();\n            const dataTypeInfo = {\n                [decoderModule.DT_FLOAT32]: { typedArrayConstructor: Float32Array, heap: decoderModule.HEAPF32 },\n                [decoderModule.DT_INT8]: { typedArrayConstructor: Int8Array, heap: decoderModule.HEAP8 },\n                [decoderModule.DT_INT16]: { typedArrayConstructor: Int16Array, heap: decoderModule.HEAP16 },\n                [decoderModule.DT_INT32]: { typedArrayConstructor: Int32Array, heap: decoderModule.HEAP32 },\n                [decoderModule.DT_UINT8]: { typedArrayConstructor: Uint8Array, heap: decoderModule.HEAPU8 },\n                [decoderModule.DT_UINT16]: { typedArrayConstructor: Uint16Array, heap: decoderModule.HEAPU16 },\n                [decoderModule.DT_UINT32]: { typedArrayConstructor: Uint32Array, heap: decoderModule.HEAPU32 },\n            };\n            const info = dataTypeInfo[dataType];\n            if (!info) {\n                throw new Error(`Invalid data type ${dataType}`);\n            }\n            const numValues = numPoints * numComponents;\n            const byteLength = numValues * info.typedArrayConstructor.BYTES_PER_ELEMENT;\n            const ptr = decoderModule._malloc(byteLength);\n            try {\n                decoder.GetAttributeDataArrayForAllPoints(geometry, attribute, dataType, byteLength, ptr);\n                const data = new info.typedArrayConstructor(info.heap.buffer, ptr, numValues);\n                onAttributeData(kind, data.slice(), numComponents, byteOffset, byteStride, normalized);\n            }\n            finally {\n                decoderModule._free(ptr);\n            }\n        };\n        if (attributes) {\n            for (const kind in attributes) {\n                const id = attributes[kind];\n                const attribute = decoder.GetAttributeByUniqueId(geometry, id);\n                processAttribute(decoder, geometry, kind, attribute);\n            }\n        }\n        else {\n            const dracoAttributeTypes = {\n                position: decoderModule.POSITION,\n                normal: decoderModule.NORMAL,\n                color: decoderModule.COLOR,\n                uv: decoderModule.TEX_COORD,\n            };\n            for (const kind in dracoAttributeTypes) {\n                const id = decoder.GetAttributeId(geometry, dracoAttributeTypes[kind]);\n                if (id !== -1) {\n                    const attribute = decoder.GetAttribute(geometry, id);\n                    processAttribute(decoder, geometry, kind, attribute);\n                }\n            }\n        }\n        return numPoints;\n    }\n    finally {\n        if (geometry) {\n            decoderModule.destroy(geometry);\n        }\n        if (buffer) {\n            decoderModule.destroy(buffer);\n        }\n        if (decoder) {\n            decoderModule.destroy(decoder);\n        }\n    }\n}\n/**\n * The worker function that gets converted to a blob url to pass into a worker.\n * To be used if a developer wants to create their own worker instance and inject it instead of using the default worker.\n */\nexport function workerFunction() {\n    let decoderPromise;\n    onmessage = (event) => {\n        const message = event.data;\n        switch (message.id) {\n            case \"init\": {\n                const decoder = message.decoder;\n                // if URL is provided then load the script. Otherwise expect the script to be loaded already\n                if (decoder.url) {\n                    importScripts(decoder.url);\n                }\n                const initDecoderObject = decoder.wasmBinary ? { wasmBinary: decoder.wasmBinary } : {};\n                decoderPromise = DracoDecoderModule(initDecoderObject);\n                postMessage({ id: \"initDone\" });\n                break;\n            }\n            case \"decodeMesh\": {\n                if (!decoderPromise) {\n                    throw new Error(\"Draco decoder module is not available\");\n                }\n                decoderPromise.then((decoder) => {\n                    const numPoints = decodeMesh(decoder, message.dataView, message.attributes, (indices) => {\n                        postMessage({ id: \"indices\", data: indices }, [indices.buffer]);\n                    }, (kind, data, size, offset, stride, normalized) => {\n                        postMessage({ id: \"attribute\", kind, data, size, byteOffset: offset, byteStride: stride, normalized }, [data.buffer]);\n                    });\n                    postMessage({ id: \"decodeMeshDone\", totalVertices: numPoints });\n                });\n                break;\n            }\n        }\n    };\n}\n/**\n * Initializes a worker that was created for the draco agent pool\n * @param worker  The worker to initialize\n * @param decoderWasmBinary The wasm binary to load into the worker\n * @param moduleUrl The url to the draco decoder module (optional)\n * @returns A promise that resolves when the worker is initialized\n */\nexport function initializeWebWorker(worker, decoderWasmBinary, moduleUrl) {\n    return new Promise((resolve, reject) => {\n        const onError = (error) => {\n            worker.removeEventListener(\"error\", onError);\n            worker.removeEventListener(\"message\", onMessage);\n            reject(error);\n        };\n        const onMessage = (event) => {\n            if (event.data.id === \"initDone\") {\n                worker.removeEventListener(\"error\", onError);\n                worker.removeEventListener(\"message\", onMessage);\n                resolve(worker);\n            }\n        };\n        worker.addEventListener(\"error\", onError);\n        worker.addEventListener(\"message\", onMessage);\n        if (!decoderWasmBinary) {\n            worker.postMessage({\n                id: \"init\",\n                decoder: {\n                    url: moduleUrl,\n                },\n            });\n        }\n        else {\n            // clone the array buffer to make it transferable\n            const clone = decoderWasmBinary.slice(0);\n            worker.postMessage({\n                id: \"init\",\n                decoder: {\n                    url: moduleUrl,\n                    wasmBinary: clone,\n                },\n            }, [clone]);\n        }\n        // note: no transfer list as the ArrayBuffer is shared across main thread and pool workers\n    });\n}\n//# sourceMappingURL=dracoCompressionWorker.js.map","import { Tools } from \"../../Misc/tools\";\nimport { AutoReleaseWorkerPool } from \"../../Misc/workerPool\";\nimport { initializeWebWorker } from \"./dracoCompressionWorker\";\n/**\n * @internal\n */\nexport function _GetDefaultNumWorkers() {\n    if (typeof navigator !== \"object\" || !navigator.hardwareConcurrency) {\n        return 1;\n    }\n    // Use 50% of the available logical processors but capped at 4.\n    return Math.min(Math.floor(navigator.hardwareConcurrency * 0.5), 4);\n}\n/**\n * @internal\n */\nexport function _IsConfigurationAvailable(config) {\n    return !!((config.wasmUrl && (config.wasmBinary || config.wasmBinaryUrl) && typeof WebAssembly === \"object\") || config.fallbackUrl);\n    // TODO: Account for jsModule\n}\n/**\n * Base class for a Draco codec.\n * @internal\n */\nexport class DracoCodec {\n    /**\n     * Constructor\n     * @param configuration The configuration for the DracoCodec instance.\n     */\n    constructor(configuration) {\n        // check if the codec binary and worker pool was injected\n        // Note - it is expected that the developer checked if WebWorker, WebAssembly and the URL object are available\n        if (configuration.workerPool) {\n            // Set the promise accordingly\n            this._workerPoolPromise = Promise.resolve(configuration.workerPool);\n            return;\n        }\n        // to avoid making big changes to the code here, if wasmBinary is provided use it in the wasmBinaryPromise\n        const wasmBinaryProvided = configuration.wasmBinary;\n        const numberOfWorkers = configuration.numWorkers ?? _GetDefaultNumWorkers();\n        const useWorkers = numberOfWorkers && typeof Worker === \"function\" && typeof URL === \"function\";\n        const urlNeeded = useWorkers || !configuration.jsModule;\n        // code maintained here for back-compat with no changes\n        const codecInfo = configuration.wasmUrl && configuration.wasmBinaryUrl && typeof WebAssembly === \"object\"\n            ? {\n                url: urlNeeded ? Tools.GetBabylonScriptURL(configuration.wasmUrl, true) : \"\",\n                wasmBinaryPromise: wasmBinaryProvided\n                    ? Promise.resolve(wasmBinaryProvided)\n                    : Tools.LoadFileAsync(Tools.GetBabylonScriptURL(configuration.wasmBinaryUrl, true)),\n            }\n            : {\n                url: urlNeeded ? Tools.GetBabylonScriptURL(configuration.fallbackUrl) : \"\",\n                wasmBinaryPromise: Promise.resolve(undefined),\n            };\n        // If using workers, initialize a worker pool with either the wasm or url?\n        if (useWorkers) {\n            this._workerPoolPromise = codecInfo.wasmBinaryPromise.then((wasmBinary) => {\n                const workerContent = this._getWorkerContent();\n                const workerBlobUrl = URL.createObjectURL(new Blob([workerContent], { type: \"application/javascript\" }));\n                return new AutoReleaseWorkerPool(numberOfWorkers, () => {\n                    const worker = new Worker(workerBlobUrl);\n                    return initializeWebWorker(worker, wasmBinary, codecInfo.url);\n                });\n            });\n        }\n        else {\n            this._modulePromise = codecInfo.wasmBinaryPromise.then(async (wasmBinary) => {\n                if (!this._isModuleAvailable()) {\n                    if (!configuration.jsModule) {\n                        if (!codecInfo.url) {\n                            throw new Error(\"Draco codec module is not available\");\n                        }\n                        await Tools.LoadBabylonScriptAsync(codecInfo.url);\n                    }\n                }\n                return this._createModuleAsync(wasmBinary, configuration.jsModule);\n            });\n        }\n    }\n    /**\n     * Returns a promise that resolves when ready. Call this manually to ensure the draco codec is ready before use.\n     * @returns a promise that resolves when ready\n     */\n    async whenReadyAsync() {\n        if (this._workerPoolPromise) {\n            await this._workerPoolPromise;\n            return;\n        }\n        if (this._modulePromise) {\n            await this._modulePromise;\n            return;\n        }\n    }\n    /**\n     * Stop all async operations and release resources.\n     */\n    dispose() {\n        if (this._workerPoolPromise) {\n            this._workerPoolPromise.then((workerPool) => {\n                workerPool.dispose();\n            });\n        }\n        delete this._workerPoolPromise;\n        delete this._modulePromise;\n    }\n}\n//# sourceMappingURL=dracoCodec.js.map","import { _IsConfigurationAvailable, DracoCodec } from \"./dracoCodec\";\nimport { Tools } from \"../../Misc/tools\";\nimport { Geometry } from \"../geometry\";\nimport { VertexBuffer } from \"../buffer\";\nimport { Logger } from \"../../Misc/logger\";\nimport { decodeMesh, workerFunction } from \"./dracoCompressionWorker\";\n/**\n * @experimental This class is an experimental version of `DracoCompression` and is subject to change.\n *\n * Draco Decoder (https://google.github.io/draco/)\n *\n * This class wraps the Draco decoder module.\n *\n * 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.\n *\n * To update the configuration, use the following code:\n * ```javascript\n *     DracoDecoder.DefaultConfiguration = {\n *          wasmUrl: \"<url to the WebAssembly library>\",\n *          wasmBinaryUrl: \"<url to the WebAssembly binary>\",\n *          fallbackUrl: \"<url to the fallback JavaScript library>\",\n *     };\n * ```\n *\n * 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.\n * Decoding will automatically fallback to the JavaScript version if WebAssembly version is not configured or if WebAssembly is not supported by the browser.\n * Use `DracoDecoder.DefaultAvailable` to determine if the decoder configuration is available for the current context.\n *\n * To decode Draco compressed data, get the default DracoDecoder object and call decodeMeshToGeometryAsync:\n * ```javascript\n *     var geometry = await DracoDecoder.Default.decodeMeshToGeometryAsync(data);\n * ```\n */\nexport class DracoDecoder extends DracoCodec {\n    /**\n     * Returns true if the decoder's `DefaultConfiguration` is available.\n     */\n    static get DefaultAvailable() {\n        return _IsConfigurationAvailable(DracoDecoder.DefaultConfiguration);\n    }\n    /**\n     * Default instance for the DracoDecoder.\n     */\n    static get Default() {\n        DracoDecoder._Default ??= new DracoDecoder();\n        return DracoDecoder._Default;\n    }\n    /**\n     * Reset the default DracoDecoder object to null and disposing the removed default instance.\n     * Note that if the workerPool is a member of the static DefaultConfiguration object it is recommended not to run dispose,\n     * unless the static worker pool is no longer needed.\n     * @param skipDispose set to true to not dispose the removed default instance\n     */\n    static ResetDefault(skipDispose) {\n        if (DracoDecoder._Default) {\n            if (!skipDispose) {\n                DracoDecoder._Default.dispose();\n            }\n            DracoDecoder._Default = null;\n        }\n    }\n    _isModuleAvailable() {\n        return typeof DracoDecoderModule !== \"undefined\";\n    }\n    async _createModuleAsync(wasmBinary, jsModule) {\n        const module = await (jsModule || DracoDecoderModule)({ wasmBinary });\n        return { module };\n    }\n    _getWorkerContent() {\n        return `${decodeMesh}(${workerFunction})()`;\n    }\n    /**\n     * Creates a new Draco decoder.\n     * @param configuration Optional override of the configuration for the DracoDecoder. If not provided, defaults to {@link DracoDecoder.DefaultConfiguration}.\n     */\n    constructor(configuration = DracoDecoder.DefaultConfiguration) {\n        super(configuration);\n    }\n    /**\n     * Decode Draco compressed mesh data to mesh data.\n     * @param data The ArrayBuffer or ArrayBufferView of the compressed Draco data\n     * @param attributes A map of attributes from vertex buffer kinds to Draco unique ids\n     * @param gltfNormalizedOverride A map of attributes from vertex buffer kinds to normalized flags to override the Draco normalization\n     * @returns A promise that resolves with the decoded mesh data\n     */\n    decodeMeshToMeshDataAsync(data, attributes, gltfNormalizedOverride) {\n        const dataView = data instanceof ArrayBuffer ? new Int8Array(data) : new Int8Array(data.buffer, data.byteOffset, data.byteLength);\n        const applyGltfNormalizedOverride = (kind, normalized) => {\n            if (gltfNormalizedOverride && gltfNormalizedOverride[kind] !== undefined) {\n                if (normalized !== gltfNormalizedOverride[kind]) {\n                    Logger.Warn(`Normalized flag from Draco data (${normalized}) does not match normalized flag from glTF accessor (${gltfNormalizedOverride[kind]}). Using flag from glTF accessor.`);\n                }\n                return gltfNormalizedOverride[kind];\n            }\n            else {\n                return normalized;\n            }\n        };\n        if (this._workerPoolPromise) {\n            return this._workerPoolPromise.then((workerPool) => {\n                return new Promise((resolve, reject) => {\n                    workerPool.push((worker, onComplete) => {\n                        let resultIndices = null;\n                        const resultAttributes = [];\n                        const onError = (error) => {\n                            worker.removeEventListener(\"error\", onError);\n                            worker.removeEventListener(\"message\", onMessage);\n                            reject(error);\n                            onComplete();\n                        };\n                        const onMessage = (event) => {\n                            const message = event.data;\n                            switch (message.id) {\n                                case \"indices\": {\n                                    resultIndices = message.data;\n                                    break;\n                                }\n                                case \"attribute\": {\n                                    resultAttributes.push({\n                                        kind: message.kind,\n                                        data: message.data,\n                                        size: message.size,\n                                        byteOffset: message.byteOffset,\n                                        byteStride: message.byteStride,\n                                        normalized: applyGltfNormalizedOverride(message.kind, message.normalized),\n                                    });\n                                    break;\n                                }\n                                case \"decodeMeshDone\": {\n                                    worker.removeEventListener(\"error\", onError);\n                                    worker.removeEventListener(\"message\", onMessage);\n                                    resolve({ indices: resultIndices, attributes: resultAttributes, totalVertices: message.totalVertices });\n                                    onComplete();\n                                    break;\n                                }\n                            }\n                        };\n                        worker.addEventListener(\"error\", onError);\n                        worker.addEventListener(\"message\", onMessage);\n                        const dataViewCopy = dataView.slice();\n                        worker.postMessage({ id: \"decodeMesh\", dataView: dataViewCopy, attributes: attributes }, [dataViewCopy.buffer]);\n                    });\n                });\n            });\n        }\n        if (this._modulePromise) {\n            return this._modulePromise.then((decoder) => {\n                let resultIndices = null;\n                const resultAttributes = [];\n                const numPoints = decodeMesh(decoder.module, dataView, attributes, (indices) => {\n                    resultIndices = indices;\n                }, (kind, data, size, byteOffset, byteStride, normalized) => {\n                    resultAttributes.push({\n                        kind,\n                        data,\n                        size,\n                        byteOffset,\n                        byteStride,\n                        normalized,\n                    });\n                });\n                return { indices: resultIndices, attributes: resultAttributes, totalVertices: numPoints };\n            });\n        }\n        throw new Error(\"Draco decoder module is not available\");\n    }\n    /**\n     * Decode Draco compressed mesh data to Babylon geometry.\n     * @param name The name to use when creating the geometry\n     * @param scene The scene to use when creating the geometry\n     * @param data The ArrayBuffer or ArrayBufferView of the Draco compressed data\n     * @param attributes A map of attributes from vertex buffer kinds to Draco unique ids\n     * @returns A promise that resolves with the decoded geometry\n     */\n    async decodeMeshToGeometryAsync(name, scene, data, attributes) {\n        const meshData = await this.decodeMeshToMeshDataAsync(data, attributes);\n        const geometry = new Geometry(name, scene);\n        if (meshData.indices) {\n            geometry.setIndices(meshData.indices);\n        }\n        for (const attribute of meshData.attributes) {\n            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);\n        }\n        return geometry;\n    }\n    /** @internal */\n    async _decodeMeshToGeometryForGltfAsync(name, scene, data, attributes, gltfNormalizedOverride, boundingInfo) {\n        const meshData = await this.decodeMeshToMeshDataAsync(data, attributes, gltfNormalizedOverride);\n        const geometry = new Geometry(name, scene);\n        if (boundingInfo) {\n            geometry._boundingInfo = boundingInfo;\n            geometry.useBoundingInfoFromGeometry = true;\n        }\n        if (meshData.indices) {\n            geometry.setIndices(meshData.indices);\n        }\n        for (const attribute of meshData.attributes) {\n            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);\n        }\n        return geometry;\n    }\n}\n/**\n * Default configuration for the DracoDecoder. Defaults to the following:\n * - numWorkers: 50% of the available logical processors, capped to 4. If no logical processors are available, defaults to 1.\n * - wasmUrl: `\"https://cdn.babylonjs.com/draco_wasm_wrapper_gltf.js\"`\n * - wasmBinaryUrl: `\"https://cdn.babylonjs.com/draco_decoder_gltf.wasm\"`\n * - fallbackUrl: `\"https://cdn.babylonjs.com/draco_decoder_gltf.js\"`\n */\nDracoDecoder.DefaultConfiguration = {\n    wasmUrl: `${Tools._DefaultCdnUrl}/draco_wasm_wrapper_gltf.js`,\n    wasmBinaryUrl: `${Tools._DefaultCdnUrl}/draco_decoder_gltf.wasm`,\n    fallbackUrl: `${Tools._DefaultCdnUrl}/draco_decoder_gltf.js`,\n};\nDracoDecoder._Default = null;\n//# sourceMappingURL=dracoDecoder.js.map","import { DracoDecoder } from \"core/Meshes/Compression/dracoDecoder\";\nimport { VertexBuffer } from \"core/Buffers/buffer\";\nimport { GLTFLoader, ArrayItem, LoadBoundingInfoFromPositionAccessor } from \"../glTFLoader\";\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\nconst NAME = \"KHR_draco_mesh_compression\";\n/**\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md)\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport class KHR_draco_mesh_compression {\n    /**\n     * @internal\n     */\n    constructor(loader) {\n        /**\n         * The name of this extension.\n         */\n        this.name = NAME;\n        /**\n         * Defines whether to use the normalized flag from the glTF accessor instead of the Draco data. Defaults to true.\n         */\n        this.useNormalizedFlagFromAccessor = true;\n        this._loader = loader;\n        this.enabled = DracoDecoder.DefaultAvailable && this._loader.isExtensionUsed(NAME);\n    }\n    /** @internal */\n    dispose() {\n        delete this.dracoDecoder;\n        this._loader = null;\n    }\n    /**\n     * @internal\n     */\n    _loadVertexDataAsync(context, primitive, babylonMesh) {\n        return GLTFLoader.LoadExtensionAsync(context, primitive, this.name, (extensionContext, extension) => {\n            if (primitive.mode != undefined) {\n                if (primitive.mode !== 4 /* MeshPrimitiveMode.TRIANGLES */ && primitive.mode !== 5 /* MeshPrimitiveMode.TRIANGLE_STRIP */) {\n                    throw new Error(`${context}: Unsupported mode ${primitive.mode}`);\n                }\n            }\n            const attributes = {};\n            const normalized = {};\n            const loadAttribute = (name, kind) => {\n                const uniqueId = extension.attributes[name];\n                if (uniqueId == undefined) {\n                    return;\n                }\n                babylonMesh._delayInfo = babylonMesh._delayInfo || [];\n                if (babylonMesh._delayInfo.indexOf(kind) === -1) {\n                    babylonMesh._delayInfo.push(kind);\n                }\n                attributes[kind] = uniqueId;\n                if (this.useNormalizedFlagFromAccessor) {\n                    const accessor = ArrayItem.TryGet(this._loader.gltf.accessors, primitive.attributes[name]);\n                    if (accessor) {\n                        normalized[kind] = accessor.normalized || false;\n                    }\n                }\n            };\n            loadAttribute(\"POSITION\", VertexBuffer.PositionKind);\n            loadAttribute(\"NORMAL\", VertexBuffer.NormalKind);\n            loadAttribute(\"TANGENT\", VertexBuffer.TangentKind);\n            loadAttribute(\"TEXCOORD_0\", VertexBuffer.UVKind);\n            loadAttribute(\"TEXCOORD_1\", VertexBuffer.UV2Kind);\n            loadAttribute(\"TEXCOORD_2\", VertexBuffer.UV3Kind);\n            loadAttribute(\"TEXCOORD_3\", VertexBuffer.UV4Kind);\n            loadAttribute(\"TEXCOORD_4\", VertexBuffer.UV5Kind);\n            loadAttribute(\"TEXCOORD_5\", VertexBuffer.UV6Kind);\n            loadAttribute(\"JOINTS_0\", VertexBuffer.MatricesIndicesKind);\n            loadAttribute(\"WEIGHTS_0\", VertexBuffer.MatricesWeightsKind);\n            loadAttribute(\"COLOR_0\", VertexBuffer.ColorKind);\n            const bufferView = ArrayItem.Get(extensionContext, this._loader.gltf.bufferViews, extension.bufferView);\n            if (!bufferView._dracoBabylonGeometry) {\n                bufferView._dracoBabylonGeometry = this._loader.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {\n                    const dracoDecoder = this.dracoDecoder || DracoDecoder.Default;\n                    const positionAccessor = ArrayItem.TryGet(this._loader.gltf.accessors, primitive.attributes[\"POSITION\"]);\n                    const babylonBoundingInfo = !this._loader.parent.alwaysComputeBoundingBox && !babylonMesh.skeleton && positionAccessor ? LoadBoundingInfoFromPositionAccessor(positionAccessor) : null;\n                    return dracoDecoder\n                        ._decodeMeshToGeometryForGltfAsync(babylonMesh.name, this._loader.babylonScene, data, attributes, normalized, babylonBoundingInfo)\n                        .catch((error) => {\n                        throw new Error(`${context}: ${error.message}`);\n                    });\n                });\n            }\n            return bufferView._dracoBabylonGeometry;\n        });\n    }\n}\nunregisterGLTFExtension(NAME);\nregisterGLTFExtension(NAME, true, (loader) => new KHR_draco_mesh_compression(loader));\n//# sourceMappingURL=KHR_draco_mesh_compression.js.map"],"names":["decodeMesh","decoderModule","data","attributes","onIndicesData","onAttributeData","decoder","buffer","geometry","status","Decoder","DecoderBuffer","Init","byteLength","type","GetEncodedGeometryType","TRIANGULAR_MESH","mesh","Mesh","DecodeBufferToMesh","ok","ptr","Error","error_msg","numIndices","num_faces","_malloc","GetTrianglesUInt32Array","indices","Uint32Array","set","HEAPF32","_free","POINT_CLOUD","pointCloud","PointCloud","DecodeBufferToPointCloud","numPoints","num_points","processAttribute","kind","attribute","dataType","data_type","numComponents","num_components","normalized","byteStride","byte_stride","byteOffset","byte_offset","info","DT_FLOAT32","typedArrayConstructor","Float32Array","heap","DT_INT8","Int8Array","HEAP8","DT_INT16","Int16Array","HEAP16","DT_INT32","Int32Array","HEAP32","DT_UINT8","Uint8Array","HEAPU8","DT_UINT16","Uint16Array","HEAPU16","DT_UINT32","HEAPU32","numValues","BYTES_PER_ELEMENT","GetAttributeDataArrayForAllPoints","slice","id","GetAttributeByUniqueId","dracoAttributeTypes","position","POSITION","normal","NORMAL","color","COLOR","uv","TEX_COORD","GetAttributeId","GetAttribute","destroy","workerFunction","decoderPromise","onmessage","event","message","url","importScripts","initDecoderObject","wasmBinary","DracoDecoderModule","postMessage","then","dataView","size","offset","stride","totalVertices","DracoCodec","constructor","configuration","workerPool","this","_workerPoolPromise","Promise","resolve","wasmBinaryProvided","numberOfWorkers","numWorkers","navigator","hardwareConcurrency","Math","min","floor","useWorkers","Worker","URL","urlNeeded","jsModule","codecInfo","wasmUrl","wasmBinaryUrl","WebAssembly","Tools","GetBabylonScriptURL","wasmBinaryPromise","LoadFileAsync","fallbackUrl","undefined","workerContent","_getWorkerContent","workerBlobUrl","createObjectURL","Blob","AutoReleaseWorkerPool","worker","decoderWasmBinary","moduleUrl","reject","onError","error","removeEventListener","onMessage","addEventListener","clone","initializeWebWorker","_modulePromise","async","_isModuleAvailable","LoadBabylonScriptAsync","_createModuleAsync","whenReadyAsync","dispose","DracoDecoder","DefaultAvailable","config","DefaultConfiguration","Default","_Default","ResetDefault","skipDispose","module","super","decodeMeshToMeshDataAsync","gltfNormalizedOverride","ArrayBuffer","push","onComplete","resultIndices","resultAttributes","Logger","Warn","dataViewCopy","decodeMeshToGeometryAsync","name","scene","meshData","Geometry","setIndices","setVerticesBuffer","VertexBuffer","getEngine","_decodeMeshToGeometryForGltfAsync","boundingInfo","_boundingInfo","useBoundingInfoFromGeometry","_DefaultCdnUrl","NAME","KHR_draco_mesh_compression","loader","useNormalizedFlagFromAccessor","_loader","enabled","isExtensionUsed","dracoDecoder","_loadVertexDataAsync","context","primitive","babylonMesh","GLTFLoader","LoadExtensionAsync","extensionContext","extension","mode","loadAttribute","uniqueId","_delayInfo","indexOf","accessor","ArrayItem","TryGet","gltf","accessors","PositionKind","NormalKind","TangentKind","UVKind","UV2Kind","UV3Kind","UV4Kind","UV5Kind","UV6Kind","MatricesIndicesKind","MatricesWeightsKind","ColorKind","bufferView","Get","bufferViews","_dracoBabylonGeometry","loadBufferViewAsync","index","positionAccessor","babylonBoundingInfo","parent","alwaysComputeBoundingBox","skeleton","LoadBoundingInfoFromPositionAccessor","babylonScene","catch","unregisterGLTFExtension","registerGLTFExtension"],"mappings":"qVAGO,SAASA,EAAWC,EAAiCC,EAAMC,EAAYC,EAAeC,GACzF,IAAIC,EAAU,KACVC,EAAS,KACTC,EAAW,KACf,IAII,IAAIC,EAHJH,EAAU,IAAIL,EAAcS,QAC5BH,EAAS,IAAIN,EAAcU,cAC3BJ,EAAOK,KAAKV,EAAMA,EAAKW,YAEvB,MAAMC,EAAOR,EAAQS,uBAAuBR,GAC5C,OAAQO,GACJ,KAAKb,EAAce,gBAAiB,CAChC,MAAMC,EAAO,IAAIhB,EAAciB,KAE/B,GADAT,EAASH,EAAQa,mBAAmBZ,EAAQU,IACvCR,EAAOW,MAAqB,IAAbH,EAAKI,IACrB,MAAM,IAAIC,MAAMb,EAAOc,aAE3B,MACMC,EAAwB,EADbP,EAAKQ,YAEhBZ,EAA0B,EAAbW,EACbH,EAAMpB,EAAcyB,QAAQb,GAClC,IACIP,EAAQqB,wBAAwBV,EAAMJ,EAAYQ,GAClD,MAAMO,EAAU,IAAIC,YAAYL,GAChCI,EAAQE,IAAI,IAAID,YAAY5B,EAAc8B,QAAQxB,OAAQc,EAAKG,IAC/DpB,EAAcwB,EAClC,CACwB,QACJ3B,EAAc+B,MAAMX,EACxC,CACgBb,EAAWS,EACX,KAChB,CACY,KAAKhB,EAAcgC,YAAa,CAC5B,MAAMC,EAAa,IAAIjC,EAAckC,WAErC,GADA1B,EAASH,EAAQ8B,yBAAyB7B,EAAQ2B,IAC7CzB,EAAOW,OAASc,EAAWb,IAC5B,MAAM,IAAIC,MAAMb,EAAOc,aAE3Bf,EAAW0B,EACX,KAChB,CACY,QACI,MAAM,IAAIZ,MAAM,yBAAyBR,KAGjD,MAAMuB,EAAY7B,EAAS8B,aACrBC,EAAmB,CAACjC,EAASE,EAAUgC,EAAMC,KAC/C,MAAMC,EAAWD,EAAUE,YACrBC,EAAgBH,EAAUI,iBAC1BC,EAAaL,EAAUK,aACvBC,EAAaN,EAAUO,cACvBC,EAAaR,EAAUS,cAUvBC,EATe,CACjB,CAAClD,EAAcmD,YAAa,CAAEC,sBAAuBC,aAAcC,KAAMtD,EAAc8B,SACvF,CAAC9B,EAAcuD,SAAU,CAAEH,sBAAuBI,UAAWF,KAAMtD,EAAcyD,OACjF,CAACzD,EAAc0D,UAAW,CAAEN,sBAAuBO,WAAYL,KAAMtD,EAAc4D,QACnF,CAAC5D,EAAc6D,UAAW,CAAET,sBAAuBU,WAAYR,KAAMtD,EAAc+D,QACnF,CAAC/D,EAAcgE,UAAW,CAAEZ,sBAAuBa,WAAYX,KAAMtD,EAAckE,QACnF,CAAClE,EAAcmE,WAAY,CAAEf,sBAAuBgB,YAAad,KAAMtD,EAAcqE,SACrF,CAACrE,EAAcsE,WAAY,CAAElB,sBAAuBxB,YAAa0B,KAAMtD,EAAcuE,UAE/D9B,GAC1B,IAAKS,EACD,MAAM,IAAI7B,MAAM,qBAAqBoB,KAEzC,MAAM+B,EAAYpC,EAAYO,EACxB/B,EAAa4D,EAAYtB,EAAKE,sBAAsBqB,kBACpDrD,EAAMpB,EAAcyB,QAAQb,GAClC,IACIP,EAAQqE,kCAAkCnE,EAAUiC,EAAWC,EAAU7B,EAAYQ,GACrF,MAAMnB,EAAO,IAAIiD,EAAKE,sBAAsBF,EAAKI,KAAKhD,OAAQc,EAAKoD,GACnEpE,EAAgBmC,EAAMtC,EAAK0E,QAAShC,EAAeK,EAAYF,EAAYD,EAC3F,CACoB,QACJ7C,EAAc+B,MAAMX,EACpC,GAEQ,GAAIlB,EACA,IAAK,MAAMqC,KAAQrC,EAAY,CAC3B,MAAM0E,EAAK1E,EAAWqC,GAChBC,EAAYnC,EAAQwE,uBAAuBtE,EAAUqE,GAC3DtC,EAAiBjC,EAASE,EAAUgC,EAAMC,EAC1D,KAEa,CACD,MAAMsC,EAAsB,CACxBC,SAAU/E,EAAcgF,SACxBC,OAAQjF,EAAckF,OACtBC,MAAOnF,EAAcoF,MACrBC,GAAIrF,EAAcsF,WAEtB,IAAK,MAAM/C,KAAQuC,EAAqB,CACpC,MAAMF,EAAKvE,EAAQkF,eAAehF,EAAUuE,EAAoBvC,IAChE,IAAY,IAARqC,EAAW,CACX,MAAMpC,EAAYnC,EAAQmF,aAAajF,EAAUqE,GACjDtC,EAAiBjC,EAASE,EAAUgC,EAAMC,EAC9D,CACA,CACA,CACQ,OAAOJ,CACf,CACY,QACA7B,GACAP,EAAcyF,QAAQlF,GAEtBD,GACAN,EAAcyF,QAAQnF,GAEtBD,GACAL,EAAcyF,QAAQpF,EAElC,CACA,CAKO,SAASqF,IACZ,IAAIC,EACJC,UAAaC,IACT,MAAMC,EAAUD,EAAM5F,KACtB,OAAQ6F,EAAQlB,IACZ,IAAK,OAAQ,CACT,MAAMvE,EAAUyF,EAAQzF,QAEpBA,EAAQ0F,KACRC,cAAc3F,EAAQ0F,KAE1B,MAAME,EAAoB5F,EAAQ6F,WAAa,CAAEA,WAAY7F,EAAQ6F,YAAe,CAAE,EACtFP,EAAiBQ,mBAAmBF,GACpCG,YAAY,CAAExB,GAAI,aAClB,KAChB,CACY,IAAK,aACD,IAAKe,EACD,MAAM,IAAItE,MAAM,yCAEpBsE,EAAeU,MAAMhG,IACjB,MAAM+B,EAAYrC,EAAWM,EAASyF,EAAQQ,SAAUR,EAAQ5F,YAAayB,IACzEyE,YAAY,CAAExB,GAAI,UAAW3E,KAAM0B,GAAW,CAACA,EAAQrB,QAAQ,IAChE,CAACiC,EAAMtC,EAAMsG,EAAMC,EAAQC,EAAQ5D,KAClCuD,YAAY,CAAExB,GAAI,YAAarC,OAAMtC,OAAMsG,OAAMvD,WAAYwD,EAAQ1D,WAAY2D,EAAQ5D,cAAc,CAAC5C,EAAKK,QAAQ,IAEzH8F,YAAY,CAAExB,GAAI,iBAAkB8B,cAAetE,GAAY,IAInF,CAEA,CCjIO,MAAMuE,EAKT,WAAAC,CAAYC,GAGR,GAAIA,EAAcC,WAGd,YADAC,KAAKC,mBAAqBC,QAAQC,QAAQL,EAAcC,aAI5D,MAAMK,EAAqBN,EAAcX,WACnCkB,EAAkBP,EAAcQ,aAhCjB,iBAAdC,WAA2BA,UAAUC,oBAIzCC,KAAKC,IAAID,KAAKE,MAAsC,GAAhCJ,UAAUC,qBAA4B,GAHtD,GAgCDI,EAAaP,GAAqC,mBAAXQ,QAAwC,mBAARC,IACvEC,EAAYH,IAAed,EAAckB,SAEzCC,EAAYnB,EAAcoB,SAAWpB,EAAcqB,eAAwC,iBAAhBC,YAC3E,CACEpC,IAAK+B,EAAYM,EAAMC,oBAAoBxB,EAAcoB,SAAS,GAAQ,GAC1EK,kBAAmBnB,EACbF,QAAQC,QAAQC,GAChBiB,EAAMG,cAAcH,EAAMC,oBAAoBxB,EAAcqB,eAAe,KAEnF,CACEnC,IAAK+B,EAAYM,EAAMC,oBAAoBxB,EAAc2B,aAAe,GACxEF,kBAAmBrB,QAAQC,aAAQuB,IAGvCd,EACAZ,KAAKC,mBAAqBgB,EAAUM,kBAAkBjC,MAAMH,IACxD,MAAMwC,EAAgB3B,KAAK4B,oBACrBC,EAAgBf,IAAIgB,gBAAgB,IAAIC,KAAK,CAACJ,GAAgB,CAAE7H,KAAM,4BAC5E,OAAO,IAAIkI,EAAsB3B,GAAiB,IDsG3D,SAA6B4B,EAAQC,EAAmBC,GAC3D,OAAO,IAAIjC,SAAQ,CAACC,EAASiC,KACzB,MAAMC,EAAWC,IACbL,EAAOM,oBAAoB,QAASF,GACpCJ,EAAOM,oBAAoB,UAAWC,GACtCJ,EAAOE,EAAM,EAEXE,EAAa1D,IACO,aAAlBA,EAAM5F,KAAK2E,KACXoE,EAAOM,oBAAoB,QAASF,GACpCJ,EAAOM,oBAAoB,UAAWC,GACtCrC,EAAQ8B,GACxB,EAIQ,GAFAA,EAAOQ,iBAAiB,QAASJ,GACjCJ,EAAOQ,iBAAiB,UAAWD,GAC9BN,EAQA,CAED,MAAMQ,EAAQR,EAAkBtE,MAAM,GACtCqE,EAAO5C,YAAY,CACfxB,GAAI,OACJvE,QAAS,CACL0F,IAAKmD,EACLhD,WAAYuD,IAEjB,CAACA,GAChB,MAjBYT,EAAO5C,YAAY,CACfxB,GAAI,OACJvE,QAAS,CACL0F,IAAKmD,IAczB,GAGA,CCzI2BQ,CADQ,IAAI9B,OAAOgB,GACS1C,EAAY8B,EAAUjC,MAC3D,IAINgB,KAAK4C,eAAiB3B,EAAUM,kBAAkBjC,MAAKuD,MAAO1D,IAC1D,IAAKa,KAAK8C,uBACDhD,EAAckB,SAAU,CACzB,IAAKC,EAAUjC,IACX,MAAM,IAAI1E,MAAM,6CAEd+G,EAAM0B,uBAAuB9B,EAAUjC,IACrE,CAEgB,OAAOgB,KAAKgD,mBAAmB7D,EAAYW,EAAckB,SAAS,GAGlF,CAKI,oBAAMiC,GACEjD,KAAKC,yBACCD,KAAKC,mBAGXD,KAAK4C,sBACC5C,KAAK4C,cAGvB,CAII,OAAAM,GACQlD,KAAKC,oBACLD,KAAKC,mBAAmBX,MAAMS,IAC1BA,EAAWmD,SAAS,WAGrBlD,KAAKC,0BACLD,KAAK4C,cACpB,ECvEO,MAAMO,UAAqBvD,EAI9B,2BAAWwD,GACP,UDtBkCC,ECsBDF,EAAaG,sBDrBhCpC,UAAYmC,EAAOlE,YAAckE,EAAOlC,gBAAyC,iBAAhBC,aAA6BiC,EAAO5B,aADpH,IAAmC4B,CCuB1C,CAII,kBAAWE,GAEP,OADAJ,EAAaK,WAAa,IAAIL,EACvBA,EAAaK,QAC5B,CAOI,mBAAOC,CAAaC,GACZP,EAAaK,WACRE,GACDP,EAAaK,SAASN,UAE1BC,EAAaK,SAAW,KAEpC,CACI,kBAAAV,GACI,MAAqC,oBAAvB1D,kBACtB,CACI,wBAAM4D,CAAmB7D,EAAY6B,GAEjC,MAAO,CAAE2C,aADa3C,GAAY5B,oBAAoB,CAAED,eAEhE,CACI,iBAAAyC,GACI,MAAO,GAAG5I,KAAc2F,MAChC,CAKI,WAAAkB,CAAYC,EAAgBqD,EAAaG,sBACrCM,MAAM9D,EACd,CAQI,yBAAA+D,CAA0B3K,EAAMC,EAAY2K,GACxC,MAAMvE,EAAWrG,aAAgB6K,YAAc,IAAItH,UAAUvD,GAAQ,IAAIuD,UAAUvD,EAAKK,OAAQL,EAAK+C,WAAY/C,EAAKW,YAYtH,GAAImG,KAAKC,mBACL,OAAOD,KAAKC,mBAAmBX,MAAMS,GAC1B,IAAIG,SAAQ,CAACC,EAASiC,KACzBrC,EAAWiE,MAAK,CAAC/B,EAAQgC,KACrB,IAAIC,EAAgB,KACpB,MAAMC,EAAmB,GACnB9B,EAAWC,IACbL,EAAOM,oBAAoB,QAASF,GACpCJ,EAAOM,oBAAoB,UAAWC,GACtCJ,EAAOE,GACP2B,GAAY,EAEVzB,EAAa1D,IACf,MAAMC,EAAUD,EAAM5F,KACtB,OAAQ6F,EAAQlB,IACZ,IAAK,UACDqG,EAAgBnF,EAAQ7F,KACxB,MAEJ,IAAK,YACDiL,EAAiBH,KAAK,CAClBxI,KAAMuD,EAAQvD,KACdtC,KAAM6F,EAAQ7F,KACdsG,KAAMT,EAAQS,KACdvD,WAAY8C,EAAQ9C,WACpBF,WAAYgD,EAAQhD,WACpBD,YArCKN,EAqCmCuD,EAAQvD,KArCrCM,EAqC2CiD,EAAQjD,WApCtFgI,QAA2DpC,IAAjCoC,EAAuBtI,IAC7CM,IAAegI,EAAuBtI,IACtC4I,EAAOC,KAAK,oCAAoCvI,yDAAkEgI,EAAuBtI,uCAEtIsI,EAAuBtI,IAGvBM,KA+Ba,MAEJ,IAAK,iBACDmG,EAAOM,oBAAoB,QAASF,GACpCJ,EAAOM,oBAAoB,UAAWC,GACtCrC,EAAQ,CAAEvF,QAASsJ,EAAe/K,WAAYgL,EAAkBxE,cAAeZ,EAAQY,gBACvFsE,IA7CQ,IAACzI,EAAMM,CAgDnD,EAEwBmG,EAAOQ,iBAAiB,QAASJ,GACjCJ,EAAOQ,iBAAiB,UAAWD,GACnC,MAAM8B,EAAe/E,EAAS3B,QAC9BqE,EAAO5C,YAAY,CAAExB,GAAI,aAAc0B,SAAU+E,EAAcnL,WAAYA,GAAc,CAACmL,EAAa/K,QAAQ,GACjH,MAId,GAAIyG,KAAK4C,eACL,OAAO5C,KAAK4C,eAAetD,MAAMhG,IAC7B,IAAI4K,EAAgB,KACpB,MAAMC,EAAmB,GACnB9I,EAAYrC,EAAWM,EAAQqK,OAAQpE,EAAUpG,GAAayB,IAChEsJ,EAAgBtJ,CAAO,IACxB,CAACY,EAAMtC,EAAMsG,EAAMvD,EAAYF,EAAYD,KAC1CqI,EAAiBH,KAAK,CAClBxI,OACAtC,OACAsG,OACAvD,aACAF,aACAD,cACF,IAEN,MAAO,CAAElB,QAASsJ,EAAe/K,WAAYgL,EAAkBxE,cAAetE,EAAW,IAGjG,MAAM,IAAIf,MAAM,wCACxB,CASI,+BAAMiK,CAA0BC,EAAMC,EAAOvL,EAAMC,GAC/C,MAAMuL,QAAiB1E,KAAK6D,0BAA0B3K,EAAMC,GACtDK,EAAW,IAAImL,EAASH,EAAMC,GAChCC,EAAS9J,SACTpB,EAASoL,WAAWF,EAAS9J,SAEjC,IAAK,MAAMa,KAAaiJ,EAASvL,WAC7BK,EAASqL,kBAAkB,IAAIC,EAAaL,EAAMM,YAAatJ,EAAUvC,KAAMuC,EAAUD,MAAM,OAAOkG,EAAWjG,EAAUM,gBAAY2F,EAAWjG,EAAUQ,WAAYR,EAAU+D,UAAMkC,EAAWjG,EAAUK,YAAY,GAAO4I,EAAS/E,eAE7O,OAAOnG,CACf,CAEI,uCAAMwL,CAAkCR,EAAMC,EAAOvL,EAAMC,EAAY2K,EAAwBmB,GAC3F,MAAMP,QAAiB1E,KAAK6D,0BAA0B3K,EAAMC,EAAY2K,GAClEtK,EAAW,IAAImL,EAASH,EAAMC,GAChCQ,IACAzL,EAAS0L,cAAgBD,EACzBzL,EAAS2L,6BAA8B,GAEvCT,EAAS9J,SACTpB,EAASoL,WAAWF,EAAS9J,SAEjC,IAAK,MAAMa,KAAaiJ,EAASvL,WAC7BK,EAASqL,kBAAkB,IAAIC,EAAaL,EAAMM,YAAatJ,EAAUvC,KAAMuC,EAAUD,MAAM,OAAOkG,EAAWjG,EAAUM,gBAAY2F,EAAWjG,EAAUQ,WAAYR,EAAU+D,UAAMkC,EAAWjG,EAAUK,YAAY,GAAO4I,EAAS/E,eAE7O,OAAOnG,CACf,EASA2J,EAAaG,qBAAuB,CAChCpC,QAAS,GAAGG,EAAM+D,4CAClBjE,cAAe,GAAGE,EAAM+D,yCACxB3D,YAAa,GAAGJ,EAAM+D,wCAE1BjC,EAAaK,SAAW,KClNxB,MAAM6B,EAAO,6BAKN,MAAMC,EAIT,WAAAzF,CAAY0F,GAIRvF,KAAKwE,KAAOa,EAIZrF,KAAKwF,+BAAgC,EACrCxF,KAAKyF,QAAUF,EACfvF,KAAK0F,QAAUvC,EAAaC,kBAAoBpD,KAAKyF,QAAQE,gBAAgBN,EACrF,CAEI,OAAAnC,UACWlD,KAAK4F,aACZ5F,KAAKyF,QAAU,IACvB,CAII,oBAAAI,CAAqBC,EAASC,EAAWC,GACrC,OAAOC,EAAWC,mBAAmBJ,EAASC,EAAW/F,KAAKwE,MAAM,CAAC2B,EAAkBC,KACnF,GAAsB1E,MAAlBqE,EAAUM,MACa,IAAnBN,EAAUM,MAAmE,IAAnBN,EAAUM,KACpE,MAAM,IAAI/L,MAAM,GAAGwL,uBAA6BC,EAAUM,QAGlE,MAAMlN,EAAa,CAAE,EACf2C,EAAa,CAAE,EACfwK,EAAgB,CAAC9B,EAAMhJ,KACzB,MAAM+K,EAAWH,EAAUjN,WAAWqL,GACtC,GAAgB9C,MAAZ6E,IAGJP,EAAYQ,WAAaR,EAAYQ,YAAc,IACL,IAA1CR,EAAYQ,WAAWC,QAAQjL,IAC/BwK,EAAYQ,WAAWxC,KAAKxI,GAEhCrC,EAAWqC,GAAQ+K,EACfvG,KAAKwF,+BAA+B,CACpC,MAAMkB,EAAWC,EAAUC,OAAO5G,KAAKyF,QAAQoB,KAAKC,UAAWf,EAAU5M,WAAWqL,IAChFkC,IACA5K,EAAWN,GAAQkL,EAAS5K,aAAc,EAElE,GAEYwK,EAAc,WAAYxB,EAAaiC,cACvCT,EAAc,SAAUxB,EAAakC,YACrCV,EAAc,UAAWxB,EAAamC,aACtCX,EAAc,aAAcxB,EAAaoC,QACzCZ,EAAc,aAAcxB,EAAaqC,SACzCb,EAAc,aAAcxB,EAAasC,SACzCd,EAAc,aAAcxB,EAAauC,SACzCf,EAAc,aAAcxB,EAAawC,SACzChB,EAAc,aAAcxB,EAAayC,SACzCjB,EAAc,WAAYxB,EAAa0C,qBACvClB,EAAc,YAAaxB,EAAa2C,qBACxCnB,EAAc,UAAWxB,EAAa4C,WACtC,MAAMC,EAAahB,EAAUiB,IAAIzB,EAAkBnG,KAAKyF,QAAQoB,KAAKgB,YAAazB,EAAUuB,YAa5F,OAZKA,EAAWG,wBACZH,EAAWG,sBAAwB9H,KAAKyF,QAAQsC,oBAAoB,gBAAgBJ,EAAWK,QAASL,GAAYrI,MAAMpG,IACtH,MAAM0M,EAAe5F,KAAK4F,cAAgBzC,EAAaI,QACjD0E,EAAmBtB,EAAUC,OAAO5G,KAAKyF,QAAQoB,KAAKC,UAAWf,EAAU5M,WAAqB,UAChG+O,EAAuBlI,KAAKyF,QAAQ0C,OAAOC,0BAA6BpC,EAAYqC,WAAYJ,EAA4E,KAAzDK,EAAqCL,GAC9J,OAAOrC,EACFZ,kCAAkCgB,EAAYxB,KAAMxE,KAAKyF,QAAQ8C,aAAcrP,EAAMC,EAAY2C,EAAYoM,GAC7GM,OAAOlG,IACR,MAAM,IAAIhI,MAAM,GAAGwL,MAAYxD,EAAMvD,UAAU,GACjD,KAGH4I,EAAWG,qBAAqB,GAEnD,EAEAW,EAAwBpD,GACxBqD,EAAsBrD,GAAM,GAAOE,GAAW,IAAID,EAA2BC"}