@caspertech/node-metaverse 0.7.40 → 0.7.51

package/dist/lib/classes/public/LLMesh.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LLMesh = void 0;
 const LLSD = require("@caspertech/llsd");
@@ -20,87 +11,82 @@ class LLMesh {
     constructor() {
         this.lodLevels = {};
     }
-    static from(buf) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const llmesh = new LLMesh();
-            const binData = new LLSD.Binary(Array.from(buf), 'BASE64');
-            let obj = LLSD.LLSD.parseBinary(binData);
-            if (obj['result'] === undefined) {
-                throw new Error('Failed to decode header');
-            }
-            if (obj['position'] === undefined) {
-                throw new Error('Position not reported');
-            }
-            const startPos = parseInt(obj['position'], 10);
-            obj = obj['result'];
-            if (!obj['version']) {
-                throw new Error('No version found');
-            }
-            if (!obj['creator']) {
-                throw new Error('Creator UUID not found');
-            }
-            if (obj['date'] === undefined) {
-                throw new Error('Date not found');
-            }
-            llmesh.creatorID = new UUID_1.UUID(obj['creator'].toString());
-            llmesh.date = obj['date'];
-            llmesh.version = parseInt(obj['version'], 10);
-            for (const key of Object.keys(obj)) {
-                const o = obj[key];
-                if (typeof o === 'object' && o !== null && o['offset'] !== undefined) {
-                    const bufFrom = startPos + parseInt(o['offset'], 10);
-                    const bufTo = startPos + parseInt(o['offset'], 10) + parseInt(o['size'], 10);
-                    const partBuf = buf.slice(bufFrom, bufTo);
-                    const deflated = yield Utils_1.Utils.inflate(partBuf);
-                    const mesh = LLSD.LLSD.parseBinary(new LLSD.Binary(Array.from(deflated), 'BASE64'));
-                    if (mesh['result'] === undefined) {
-                        throw new Error('Failed to parse compressed submesh data');
-                    }
-                    if (key === 'physics_convex') {
-                        llmesh.physicsConvex = this.parsePhysicsConvex(mesh['result']);
-                    }
-                    else if (key === 'skin') {
-                        llmesh.skin = this.parseSkin(mesh['result']);
-                    }
-                    else if (key === 'physics_havok' || key === 'physics_cost_data') {
-                    }
-                    else {
-                        llmesh.lodLevels[key] = this.parseLODLevel(mesh['result']);
-                    }
+    static async from(buf) {
+        const llmesh = new LLMesh();
+        const binData = new LLSD.Binary(Array.from(buf), 'BASE64');
+        let obj = LLSD.LLSD.parseBinary(binData);
+        if (obj.result === undefined) {
+            throw new Error('Failed to decode header');
+        }
+        if (obj.position === undefined) {
+            throw new Error('Position not reported');
+        }
+        const startPos = parseInt(obj.position, 10);
+        obj = obj.result;
+        if (obj.creator !== undefined) {
+            llmesh.creatorID = new UUID_1.UUID(obj.creator.toString());
+        }
+        if (obj.date !== undefined) {
+            llmesh.date = obj.date;
+        }
+        if (obj.version !== undefined) {
+            llmesh.version = parseInt(obj.version, 10);
+        }
+        for (const key of Object.keys(obj)) {
+            const o = obj[key];
+            if (typeof o === 'object' && o !== null && o.offset !== undefined) {
+                const bufFrom = startPos + parseInt(o.offset, 10);
+                const bufTo = startPos + parseInt(o.offset, 10) + parseInt(o.size, 10);
+                const partBuf = buf.subarray(bufFrom, bufTo);
+                const deflated = await Utils_1.Utils.inflate(partBuf);
+                const mesh = LLSD.LLSD.parseBinary(new LLSD.Binary(Array.from(deflated), 'BASE64'));
+                if (mesh.result === undefined) {
+                    throw new Error('Failed to parse compressed submesh data');
+                }
+                if (key === 'physics_convex') {
+                    llmesh.physicsConvex = this.parsePhysicsConvex(mesh.result);
+                }
+                else if (key === 'skin') {
+                    llmesh.skin = this.parseSkin(mesh.result);
+                }
+                else if (key === 'physics_havok' || key === 'physics_cost_data') {
+                }
+                else {
+                    llmesh.lodLevels[key] = this.parseLODLevel(mesh.result);
                 }
             }
-            return llmesh;
-        });
+        }
+        return llmesh;
     }
     static parseSkin(mesh) {
-        if (!mesh['joint_names']) {
+        if (mesh.joint_names === undefined) {
             throw new Error('Joint names missing from skin');
         }
-        if (!mesh['bind_shape_matrix']) {
+        if (mesh.bind_shape_matrix === undefined) {
             throw new Error('Bind shape matrix missing from skin');
         }
-        if (!mesh['inverse_bind_matrix']) {
+        if (mesh.inverse_bind_matrix === undefined) {
             throw new Error('Inverse bind matrix missing from skin');
         }
         const skin = {
-            jointNames: mesh['joint_names'],
-            bindShapeMatrix: new mat4_1.TSMMat4(mesh['bind_shape_matrix']),
+            jointNames: mesh.joint_names,
+            bindShapeMatrix: new mat4_1.TSMMat4(mesh.bind_shape_matrix),
             inverseBindMatrix: []
         };
-        if (mesh['inverse_bind_matrix']) {
+        if (mesh.inverse_bind_matrix !== undefined) {
             skin.inverseBindMatrix = [];
-            for (const inv of mesh['inverse_bind_matrix']) {
+            for (const inv of mesh.inverse_bind_matrix) {
                 skin.inverseBindMatrix.push(new mat4_1.TSMMat4(inv));
             }
         }
-        if (mesh['alt_inverse_bind_matrix']) {
+        if (mesh.alt_inverse_bind_matrix !== undefined) {
             skin.altInverseBindMatrix = [];
-            for (const inv of mesh['alt_inverse_bind_matrix']) {
+            for (const inv of mesh.alt_inverse_bind_matrix) {
                 skin.altInverseBindMatrix.push(new mat4_1.TSMMat4(inv));
             }
         }
-        if (mesh['pelvis_offset']) {
-            skin.pelvisOffset = new mat4_1.TSMMat4(mesh['pelvis_offset']);
+        if (mesh.pelvis_offset !== undefined) {
+            skin.pelvisOffset = new mat4_1.TSMMat4(mesh.pelvis_offset);
         }
         return skin;
     }
@@ -122,22 +108,22 @@ class LLMesh {
                 max: new Vector3_1.Vector3([0.5, 0.5, 0.5])
             }
         };
-        if (mesh['Min']) {
-            conv.domain.min.x = mesh['Min'][0];
-            conv.domain.min.y = mesh['Min'][1];
-            conv.domain.min.z = mesh['Min'][2];
-        }
-        if (mesh['Max']) {
-            conv.domain.max.x = mesh['Max'][0];
-            conv.domain.max.y = mesh['Max'][1];
-            conv.domain.max.z = mesh['Max'][2];
-        }
-        if (mesh['HullList']) {
-            if (!mesh['Positions']) {
+        if (mesh.Min !== undefined) {
+            conv.domain.min.x = mesh.Min[0];
+            conv.domain.min.y = mesh.Min[1];
+            conv.domain.min.z = mesh.Min[2];
+        }
+        if (mesh.Max !== undefined) {
+            conv.domain.max.x = mesh.Max[0];
+            conv.domain.max.y = mesh.Max[1];
+            conv.domain.max.z = mesh.Max[2];
+        }
+        if (mesh.HullList !== undefined) {
+            if (mesh.Positions === undefined) {
                 throw new Error('Positions must be supplied if hull list is present');
             }
-            conv.positions = this.decodeByteDomain3(mesh['Positions'].toArray(), conv.domain.min, conv.domain.max);
-            conv.hullList = mesh['HullList'].toArray();
+            conv.positions = this.decodeByteDomain3(mesh.Positions.toArray(), conv.domain.min, conv.domain.max);
+            conv.hullList = mesh.HullList.toArray();
             if (conv.hullList === undefined) {
                 throw new Error('HullList undefined');
             }
@@ -151,10 +137,10 @@ class LLMesh {
                 }
             }
         }
-        if (!mesh['BoundingVerts']) {
+        if (mesh.BoundingVerts === undefined) {
             throw new Error('BoundingVerts is required');
         }
-        conv.boundingVerts = this.decodeByteDomain3(mesh['BoundingVerts'].toArray(), conv.domain.min, conv.domain.max);
+        conv.boundingVerts = this.decodeByteDomain3(mesh.BoundingVerts.toArray(), conv.domain.min, conv.domain.max);
         return conv;
     }
     static parseLODLevel(mesh) {
@@ -166,51 +152,51 @@ class LLMesh {
                     max: new Vector3_1.Vector3([0.5, 0.5, 0.5])
                 }
             };
-            if (submesh['NoGeometry']) {
+            if (submesh.NoGeometry) {
                 decoded.noGeometry = true;
                 list.push(decoded);
             }
             else {
                 decoded.position = [];
-                if (!submesh['Position']) {
+                if (!submesh.Position) {
                     throw new Error('Submesh does not contain position data');
                 }
                 if (decoded.positionDomain !== undefined) {
-                    if (submesh['PositionDomain']) {
-                        if (submesh['PositionDomain']['Max'] !== undefined) {
-                            const dom = submesh['PositionDomain']['Max'];
+                    if (submesh.PositionDomain) {
+                        if (submesh.PositionDomain.Max !== undefined) {
+                            const dom = submesh.PositionDomain.Max;
                             decoded.positionDomain.max.x = dom[0];
                             decoded.positionDomain.max.y = dom[1];
                             decoded.positionDomain.max.z = dom[2];
                         }
-                        if (submesh['PositionDomain']['Min'] !== undefined) {
-                            const dom = submesh['PositionDomain']['Min'];
+                        if (submesh.PositionDomain.Min !== undefined) {
+                            const dom = submesh.PositionDomain.Min;
                             decoded.positionDomain.min.x = dom[0];
                             decoded.positionDomain.min.y = dom[1];
                             decoded.positionDomain.min.z = dom[2];
                         }
                     }
-                    decoded.position = this.decodeByteDomain3(submesh['Position'].toArray(), decoded.positionDomain.min, decoded.positionDomain.max);
+                    decoded.position = this.decodeByteDomain3(submesh.Position.toArray(), decoded.positionDomain.min, decoded.positionDomain.max);
                 }
-                if (submesh['Normal']) {
-                    decoded.normal = this.decodeByteDomain3(submesh['Normal'].toArray(), new Vector3_1.Vector3([-1.0, -1.0, -1.0]), new Vector3_1.Vector3([1.0, 1.0, 1.0]));
+                if (submesh.Normal) {
+                    decoded.normal = this.decodeByteDomain3(submesh.Normal.toArray(), new Vector3_1.Vector3([-1.0, -1.0, -1.0]), new Vector3_1.Vector3([1.0, 1.0, 1.0]));
                     if (decoded.normal.length !== decoded.position.length) {
                         throw new Error('Normal length does not match vertex position length');
                     }
                 }
-                if (submesh['TexCoord0']) {
+                if (submesh.TexCoord0) {
                     decoded.texCoord0Domain = {
                         min: new Vector2_1.Vector2([-0.5, -0.5]),
                         max: new Vector2_1.Vector2([0.5, 0.5])
                     };
-                    if (submesh['TexCoord0Domain']) {
-                        if (submesh['TexCoord0Domain']['Max'] !== undefined) {
-                            const dom = submesh['TexCoord0Domain']['Max'];
+                    if (submesh.TexCoord0Domain) {
+                        if (submesh.TexCoord0Domain.Max !== undefined) {
+                            const dom = submesh.TexCoord0Domain.Max;
                             decoded.texCoord0Domain.max.x = dom[0];
                             decoded.texCoord0Domain.max.y = dom[1];
                         }
-                        if (submesh['TexCoord0Domain']['Min'] !== undefined) {
-                            const dom = submesh['TexCoord0Domain']['Min'];
+                        if (submesh.TexCoord0Domain.Min !== undefined) {
+                            const dom = submesh.TexCoord0Domain.Min;
                             decoded.texCoord0Domain.min.x = dom[0];
                             decoded.texCoord0Domain.min.y = dom[1];
                         }
@@ -218,12 +204,12 @@ class LLMesh {
                     else {
                         throw new Error('TexCoord0Domain is required if Texcoord0 is present');
                     }
-                    decoded.texCoord0 = this.decodeByteDomain2(submesh['TexCoord0'].toArray(), decoded.texCoord0Domain.min, decoded.texCoord0Domain.max);
+                    decoded.texCoord0 = this.decodeByteDomain2(submesh.TexCoord0.toArray(), decoded.texCoord0Domain.min, decoded.texCoord0Domain.max);
                 }
-                if (!submesh['TriangleList']) {
+                if (!submesh.TriangleList) {
                     throw new Error('TriangleList is required');
                 }
-                const indexBuf = Buffer.from(submesh['TriangleList'].toArray());
+                const indexBuf = Buffer.from(submesh.TriangleList.toArray());
                 decoded.triangleList = [];
                 for (let pos = 0; pos < indexBuf.length; pos = pos + 2) {
                     const vertIndex = indexBuf.readUInt16LE(pos);
@@ -232,8 +218,8 @@ class LLMesh {
                     }
                     decoded.triangleList.push(vertIndex);
                 }
-                if (submesh['Weights']) {
-                    const skinBuf = Buffer.from(submesh['Weights'].toArray());
+                if (submesh.Weights) {
+                    const skinBuf = Buffer.from(submesh.Weights.toArray());
                     decoded.weights = [];
                     let pos = 0;
                     while (pos < skinBuf.length) {
@@ -282,6 +268,44 @@ class LLMesh {
     static normalizeDomain(value, min, max) {
         return ((value / 65535) * (max - min)) + min;
     }
+    async toAsset() {
+        const llsd = {
+            'creator': new LLSD.UUID(this.creatorID.toString()),
+            'version': this.version,
+            'date': null
+        };
+        let offset = 0;
+        const bufs = [];
+        for (const lod of Object.keys(this.lodLevels)) {
+            const lodBlob = await this.encodeLODLevel(lod, this.lodLevels[lod]);
+            llsd[lod] = {
+                'offset': offset,
+                'size': lodBlob.length
+            };
+            offset += lodBlob.length;
+            bufs.push(lodBlob);
+        }
+        if (this.physicsConvex) {
+            const physBlob = await this.encodePhysicsConvex(this.physicsConvex);
+            llsd.physics_convex = {
+                'offset': offset,
+                'size': physBlob.length
+            };
+            offset += physBlob.length;
+            bufs.push(physBlob);
+        }
+        if (this.skin) {
+            const skinBlob = await this.encodeSkin(this.skin);
+            llsd.skin = {
+                'offset': offset,
+                'size': skinBlob.length
+            };
+            offset += skinBlob.length;
+            bufs.push(skinBlob);
+        }
+        bufs.unshift(Buffer.from(LLSD.LLSD.formatBinary(llsd).toArray()));
+        return Buffer.concat(bufs);
+    }
     encodeSubMesh(mesh) {
         const data = {};
         if (mesh.noGeometry === true) {
@@ -311,8 +335,8 @@ class LLMesh {
         if (mesh.triangleList) {
             const triangles = Buffer.allocUnsafe(mesh.triangleList.length * 2);
             let pos = 0;
-            for (let x = 0; x < mesh.triangleList.length; x++) {
-                triangles.writeUInt16LE(mesh.triangleList[x], pos);
+            for (const triangle of mesh.triangleList) {
+                triangles.writeUInt16LE(triangle, pos);
                 pos = pos + 2;
             }
             data.triangleList = new LLSD.Binary(Array.from(triangles));
@@ -372,120 +396,74 @@ class LLMesh {
         }
         return buf;
     }
-    encodeLODLevel(_, submeshes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const smList = [];
-            for (const sub of submeshes) {
-                smList.push(this.encodeSubMesh(sub));
-            }
-            const mesh = LLSD.LLSD.formatBinary(smList);
-            return Utils_1.Utils.deflate(Buffer.from(mesh.toArray()));
-        });
-    }
-    encodePhysicsConvex(conv) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const llsd = {
-                Min: LLMesh.fixReal(conv.domain.min.toArray()),
-                Max: LLMesh.fixReal(conv.domain.max.toArray())
-            };
-            const sizeX = conv.domain.max.x - conv.domain.min.x;
-            const sizeY = conv.domain.max.y - conv.domain.min.y;
-            const sizeZ = conv.domain.max.z - conv.domain.min.z;
-            if (conv.hullList) {
-                if (!conv.positions) {
-                    throw new Error('Positions must be present if hullList is set.');
-                }
-                llsd.HullList = new LLSD.Binary(conv.hullList);
-                const buf = Buffer.allocUnsafe(conv.positions.length * 6);
-                let pos = 0;
-                for (const vec of conv.positions) {
-                    buf.writeUInt16LE(Math.round(((vec.x - conv.domain.min.x) / sizeX) * 65535), pos);
-                    pos = pos + 2;
-                    buf.writeUInt16LE(Math.round(((vec.y - conv.domain.min.y) / sizeY) * 65535), pos);
-                    pos = pos + 2;
-                    buf.writeUInt16LE(Math.round(((vec.z - conv.domain.min.z) / sizeZ) * 65535), pos);
-                    pos = pos + 2;
-                }
-                llsd.Positions = new LLSD.Binary(Array.from(buf));
-            }
-            {
-                const buf = Buffer.allocUnsafe(conv.boundingVerts.length * 6);
-                let pos = 0;
-                for (const vec of conv.boundingVerts) {
-                    buf.writeUInt16LE(Math.round(((vec.x - conv.domain.min.x) / sizeX)) * 65535, pos);
-                    pos = pos + 2;
-                    buf.writeUInt16LE(Math.round(((vec.y - conv.domain.min.y) / sizeY)) * 65535, pos);
-                    pos = pos + 2;
-                    buf.writeUInt16LE(Math.round(((vec.z - conv.domain.min.z) / sizeZ)) * 65535, pos);
-                    pos = pos + 2;
-                }
-                llsd.BoundingVerts = new LLSD.Binary(Array.from(buf));
-            }
-            const mesh = LLSD.LLSD.formatBinary(llsd);
-            return yield Utils_1.Utils.deflate(Buffer.from(mesh.toArray()));
-        });
+    async encodeLODLevel(_, submeshes) {
+        const smList = [];
+        for (const sub of submeshes) {
+            smList.push(this.encodeSubMesh(sub));
+        }
+        const mesh = LLSD.LLSD.formatBinary(smList);
+        return Utils_1.Utils.deflate(Buffer.from(mesh.toArray()));
     }
-    encodeSkin(skin) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const llsd = {};
-            llsd['joint_names'] = skin.jointNames;
-            llsd['bind_shape_matrix'] = skin.bindShapeMatrix.toArray();
-            llsd['inverse_bind_matrix'] = [];
-            for (const matrix of skin.inverseBindMatrix) {
-                llsd['inverse_bind_matrix'].push(matrix.toArray());
+    async encodePhysicsConvex(conv) {
+        const llsd = {
+            Min: LLMesh.fixReal(conv.domain.min.toArray()),
+            Max: LLMesh.fixReal(conv.domain.max.toArray())
+        };
+        const sizeX = conv.domain.max.x - conv.domain.min.x;
+        const sizeY = conv.domain.max.y - conv.domain.min.y;
+        const sizeZ = conv.domain.max.z - conv.domain.min.z;
+        if (conv.hullList) {
+            if (!conv.positions) {
+                throw new Error('Positions must be present if hullList is set.');
             }
-            if (skin.altInverseBindMatrix) {
-                llsd['alt_inverse_bind_matrix'] = [];
-                for (const matrix of skin.altInverseBindMatrix) {
-                    llsd['alt_inverse_bind_matrix'].push(matrix.toArray());
-                }
+            llsd.HullList = new LLSD.Binary(conv.hullList);
+            const buf = Buffer.allocUnsafe(conv.positions.length * 6);
+            let pos = 0;
+            for (const vec of conv.positions) {
+                buf.writeUInt16LE(Math.round(((vec.x - conv.domain.min.x) / sizeX) * 65535), pos);
+                pos = pos + 2;
+                buf.writeUInt16LE(Math.round(((vec.y - conv.domain.min.y) / sizeY) * 65535), pos);
+                pos = pos + 2;
+                buf.writeUInt16LE(Math.round(((vec.z - conv.domain.min.z) / sizeZ) * 65535), pos);
+                pos = pos + 2;
             }
-            if (skin.pelvisOffset) {
-                llsd['pelvis_offset'] = skin.pelvisOffset.toArray();
+            llsd.Positions = new LLSD.Binary(Array.from(buf));
+        }
+        {
+            const buf = Buffer.allocUnsafe(conv.boundingVerts.length * 6);
+            let pos = 0;
+            for (const vec of conv.boundingVerts) {
+                buf.writeUInt16LE(Math.round(((vec.x - conv.domain.min.x) / sizeX)) * 65535, pos);
+                pos = pos + 2;
+                buf.writeUInt16LE(Math.round(((vec.y - conv.domain.min.y) / sizeY)) * 65535, pos);
+                pos = pos + 2;
+                buf.writeUInt16LE(Math.round(((vec.z - conv.domain.min.z) / sizeZ)) * 65535, pos);
+                pos = pos + 2;
             }
-            const mesh = LLSD.LLSD.formatBinary(llsd);
-            return yield Utils_1.Utils.deflate(Buffer.from(mesh.toArray()));
-        });
+            llsd.BoundingVerts = new LLSD.Binary(Array.from(buf));
+        }
+        const mesh = LLSD.LLSD.formatBinary(llsd);
+        return Utils_1.Utils.deflate(Buffer.from(mesh.toArray()));
     }
-    toAsset() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const llsd = {
-                'creator': new LLSD.UUID(this.creatorID.toString()),
-                'version': this.version,
-                'date': null
-            };
-            let offset = 0;
-            const bufs = [];
-            for (const lod of Object.keys(this.lodLevels)) {
-                const lodBlob = yield this.encodeLODLevel(lod, this.lodLevels[lod]);
-                llsd[lod] = {
-                    'offset': offset,
-                    'size': lodBlob.length
-                };
-                offset += lodBlob.length;
-                bufs.push(lodBlob);
-            }
-            if (this.physicsConvex) {
-                const physBlob = yield this.encodePhysicsConvex(this.physicsConvex);
-                llsd['physics_convex'] = {
-                    'offset': offset,
-                    'size': physBlob.length
-                };
-                offset += physBlob.length;
-                bufs.push(physBlob);
-            }
-            if (this.skin) {
-                const skinBlob = yield this.encodeSkin(this.skin);
-                llsd['skin'] = {
-                    'offset': offset,
-                    'size': skinBlob.length
-                };
-                offset += skinBlob.length;
-                bufs.push(skinBlob);
+    async encodeSkin(skin) {
+        const llsd = {};
+        llsd.joint_names = skin.jointNames;
+        llsd.bind_shape_matrix = skin.bindShapeMatrix.toArray();
+        llsd.inverse_bind_matrix = [];
+        for (const matrix of skin.inverseBindMatrix) {
+            llsd.inverse_bind_matrix.push(matrix.toArray());
+        }
+        if (skin.altInverseBindMatrix) {
+            llsd.alt_inverse_bind_matrix = [];
+            for (const matrix of skin.altInverseBindMatrix) {
+                llsd.alt_inverse_bind_matrix.push(matrix.toArray());
             }
-            bufs.unshift(Buffer.from(LLSD.LLSD.formatBinary(llsd).toArray()));
-            return Buffer.concat(bufs);
-        });
+        }
+        if (skin.pelvisOffset) {
+            llsd.pelvis_offset = skin.pelvisOffset.toArray();
+        }
+        const mesh = LLSD.LLSD.formatBinary(llsd);
+        return Utils_1.Utils.deflate(Buffer.from(mesh.toArray()));
     }
 }
 exports.LLMesh = LLMesh;