roavatar-renderer 1.2.13 → 1.2.14

package/dist/index.js

@@ -15991,76 +15991,76 @@ class PropertyBinding {
   _setValue_unavailable() {
   }
   // Getters
-  _getValue_direct(buffer, offset) {
-    buffer[offset] = this.targetObject[this.propertyName];
+  _getValue_direct(buffer2, offset) {
+    buffer2[offset] = this.targetObject[this.propertyName];
   }
-  _getValue_array(buffer, offset) {
+  _getValue_array(buffer2, offset) {
     const source = this.resolvedProperty;
     for (let i = 0, n = source.length; i !== n; ++i) {
-      buffer[offset++] = source[i];
+      buffer2[offset++] = source[i];
     }
   }
-  _getValue_arrayElement(buffer, offset) {
-    buffer[offset] = this.resolvedProperty[this.propertyIndex];
+  _getValue_arrayElement(buffer2, offset) {
+    buffer2[offset] = this.resolvedProperty[this.propertyIndex];
   }
-  _getValue_toArray(buffer, offset) {
-    this.resolvedProperty.toArray(buffer, offset);
+  _getValue_toArray(buffer2, offset) {
+    this.resolvedProperty.toArray(buffer2, offset);
   }
   // Direct
-  _setValue_direct(buffer, offset) {
-    this.targetObject[this.propertyName] = buffer[offset];
+  _setValue_direct(buffer2, offset) {
+    this.targetObject[this.propertyName] = buffer2[offset];
   }
-  _setValue_direct_setNeedsUpdate(buffer, offset) {
-    this.targetObject[this.propertyName] = buffer[offset];
+  _setValue_direct_setNeedsUpdate(buffer2, offset) {
+    this.targetObject[this.propertyName] = buffer2[offset];
     this.targetObject.needsUpdate = true;
   }
-  _setValue_direct_setMatrixWorldNeedsUpdate(buffer, offset) {
-    this.targetObject[this.propertyName] = buffer[offset];
+  _setValue_direct_setMatrixWorldNeedsUpdate(buffer2, offset) {
+    this.targetObject[this.propertyName] = buffer2[offset];
     this.targetObject.matrixWorldNeedsUpdate = true;
   }
   // EntireArray
-  _setValue_array(buffer, offset) {
+  _setValue_array(buffer2, offset) {
     const dest = this.resolvedProperty;
     for (let i = 0, n = dest.length; i !== n; ++i) {
-      dest[i] = buffer[offset++];
+      dest[i] = buffer2[offset++];
     }
   }
-  _setValue_array_setNeedsUpdate(buffer, offset) {
+  _setValue_array_setNeedsUpdate(buffer2, offset) {
     const dest = this.resolvedProperty;
     for (let i = 0, n = dest.length; i !== n; ++i) {
-      dest[i] = buffer[offset++];
+      dest[i] = buffer2[offset++];
     }
     this.targetObject.needsUpdate = true;
   }
-  _setValue_array_setMatrixWorldNeedsUpdate(buffer, offset) {
+  _setValue_array_setMatrixWorldNeedsUpdate(buffer2, offset) {
     const dest = this.resolvedProperty;
     for (let i = 0, n = dest.length; i !== n; ++i) {
-      dest[i] = buffer[offset++];
+      dest[i] = buffer2[offset++];
     }
     this.targetObject.matrixWorldNeedsUpdate = true;
   }
   // ArrayElement
-  _setValue_arrayElement(buffer, offset) {
-    this.resolvedProperty[this.propertyIndex] = buffer[offset];
+  _setValue_arrayElement(buffer2, offset) {
+    this.resolvedProperty[this.propertyIndex] = buffer2[offset];
   }
-  _setValue_arrayElement_setNeedsUpdate(buffer, offset) {
-    this.resolvedProperty[this.propertyIndex] = buffer[offset];
+  _setValue_arrayElement_setNeedsUpdate(buffer2, offset) {
+    this.resolvedProperty[this.propertyIndex] = buffer2[offset];
     this.targetObject.needsUpdate = true;
   }
-  _setValue_arrayElement_setMatrixWorldNeedsUpdate(buffer, offset) {
-    this.resolvedProperty[this.propertyIndex] = buffer[offset];
+  _setValue_arrayElement_setMatrixWorldNeedsUpdate(buffer2, offset) {
+    this.resolvedProperty[this.propertyIndex] = buffer2[offset];
     this.targetObject.matrixWorldNeedsUpdate = true;
   }
   // HasToFromArray
-  _setValue_fromArray(buffer, offset) {
-    this.resolvedProperty.fromArray(buffer, offset);
+  _setValue_fromArray(buffer2, offset) {
+    this.resolvedProperty.fromArray(buffer2, offset);
   }
-  _setValue_fromArray_setNeedsUpdate(buffer, offset) {
-    this.resolvedProperty.fromArray(buffer, offset);
+  _setValue_fromArray_setNeedsUpdate(buffer2, offset) {
+    this.resolvedProperty.fromArray(buffer2, offset);
     this.targetObject.needsUpdate = true;
   }
-  _setValue_fromArray_setMatrixWorldNeedsUpdate(buffer, offset) {
-    this.resolvedProperty.fromArray(buffer, offset);
+  _setValue_fromArray_setMatrixWorldNeedsUpdate(buffer2, offset) {
+    this.resolvedProperty.fromArray(buffer2, offset);
     this.targetObject.matrixWorldNeedsUpdate = true;
   }
   _getValue_unbound(targetArray, offset) {
@@ -16630,8 +16630,8 @@ function WebGLAttributes(gl) {
     const array = attribute.array;
     const usage = attribute.usage;
     const size = array.byteLength;
-    const buffer = gl.createBuffer();
-    gl.bindBuffer(bufferType, buffer);
+    const buffer2 = gl.createBuffer();
+    gl.bindBuffer(bufferType, buffer2);
     gl.bufferData(bufferType, array, usage);
     attribute.onUploadCallback();
     let type;
@@ -16661,17 +16661,17 @@ function WebGLAttributes(gl) {
       throw new Error("THREE.WebGLAttributes: Unsupported buffer data format: " + array);
     }
     return {
-      buffer,
+      buffer: buffer2,
       type,
       bytesPerElement: array.BYTES_PER_ELEMENT,
       version: attribute.version,
       size
     };
   }
-  function updateBuffer(buffer, attribute, bufferType) {
+  function updateBuffer(buffer2, attribute, bufferType) {
     const array = attribute.array;
     const updateRanges = attribute.updateRanges;
-    gl.bindBuffer(bufferType, buffer);
+    gl.bindBuffer(bufferType, buffer2);
     if (updateRanges.length === 0) {
       gl.bufferSubData(bufferType, 0, array);
     } else {
@@ -17826,7 +17826,7 @@ function WebGLBindingStates(gl, attributes) {
           const size = geometryAttribute.itemSize;
           const attribute = attributes.get(geometryAttribute);
           if (attribute === void 0) continue;
-          const buffer = attribute.buffer;
+          const buffer2 = attribute.buffer;
           const type = attribute.type;
           const bytesPerElement = attribute.bytesPerElement;
           const integer = type === gl.INT || type === gl.UNSIGNED_INT || geometryAttribute.gpuType === IntType;
@@ -17846,7 +17846,7 @@ function WebGLBindingStates(gl, attributes) {
                 enableAttribute(programAttribute.location + i);
               }
             }
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer2);
             for (let i = 0; i < programAttribute.locationSize; i++) {
               vertexAttribPointer(
                 programAttribute.location + i,
@@ -17871,7 +17871,7 @@ function WebGLBindingStates(gl, attributes) {
                 enableAttribute(programAttribute.location + i);
               }
             }
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer2);
             for (let i = 0; i < programAttribute.locationSize; i++) {
               vertexAttribPointer(
                 programAttribute.location + i,
@@ -19242,8 +19242,8 @@ function WebGLMorphtargets(gl, capabilities, textures) {
         height = Math.ceil(width / capabilities.maxTextureSize);
         width = capabilities.maxTextureSize;
       }
-      const buffer = new Float32Array(width * height * 4 * morphTargetsCount);
-      const texture = new DataArrayTexture(buffer, width, height, morphTargetsCount);
+      const buffer2 = new Float32Array(width * height * 4 * morphTargetsCount);
+      const texture = new DataArrayTexture(buffer2, width, height, morphTargetsCount);
       texture.type = FloatType;
       texture.needsUpdate = true;
       const vertexDataStride = vertexDataCount * 4;
@@ -19256,24 +19256,24 @@ function WebGLMorphtargets(gl, capabilities, textures) {
           const stride = j * vertexDataStride;
           if (hasMorphPosition === true) {
             morph.fromBufferAttribute(morphTarget, j);
-            buffer[offset + stride + 0] = morph.x;
-            buffer[offset + stride + 1] = morph.y;
-            buffer[offset + stride + 2] = morph.z;
-            buffer[offset + stride + 3] = 0;
+            buffer2[offset + stride + 0] = morph.x;
+            buffer2[offset + stride + 1] = morph.y;
+            buffer2[offset + stride + 2] = morph.z;
+            buffer2[offset + stride + 3] = 0;
           }
           if (hasMorphNormals === true) {
             morph.fromBufferAttribute(morphNormal, j);
-            buffer[offset + stride + 4] = morph.x;
-            buffer[offset + stride + 5] = morph.y;
-            buffer[offset + stride + 6] = morph.z;
-            buffer[offset + stride + 7] = 0;
+            buffer2[offset + stride + 4] = morph.x;
+            buffer2[offset + stride + 5] = morph.y;
+            buffer2[offset + stride + 6] = morph.z;
+            buffer2[offset + stride + 7] = 0;
           }
           if (hasMorphColors === true) {
             morph.fromBufferAttribute(morphColor, j);
-            buffer[offset + stride + 8] = morph.x;
-            buffer[offset + stride + 9] = morph.y;
-            buffer[offset + stride + 10] = morph.z;
-            buffer[offset + stride + 11] = morphColor.itemSize === 4 ? morph.w : 1;
+            buffer2[offset + stride + 8] = morph.x;
+            buffer2[offset + stride + 9] = morph.y;
+            buffer2[offset + stride + 10] = morph.z;
+            buffer2[offset + stride + 11] = morphColor.itemSize === 4 ? morph.w : 1;
           }
         }
       }
@@ -24986,11 +24986,11 @@ function WebGLUniformsGroups(gl, info, capabilities, state) {
     state.uniformBlockBinding(uniformsGroup, webglProgram);
   }
   function update(uniformsGroup, program) {
-    let buffer = buffers[uniformsGroup.id];
-    if (buffer === void 0) {
+    let buffer2 = buffers[uniformsGroup.id];
+    if (buffer2 === void 0) {
       prepareUniformsGroup(uniformsGroup);
-      buffer = createBuffer(uniformsGroup);
-      buffers[uniformsGroup.id] = buffer;
+      buffer2 = createBuffer(uniformsGroup);
+      buffers[uniformsGroup.id] = buffer2;
       uniformsGroup.addEventListener("dispose", onUniformsGroupsDispose);
     }
     const webglProgram = program.program;
@@ -25004,14 +25004,14 @@ function WebGLUniformsGroups(gl, info, capabilities, state) {
   function createBuffer(uniformsGroup) {
     const bindingPointIndex = allocateBindingPointIndex();
     uniformsGroup.__bindingPointIndex = bindingPointIndex;
-    const buffer = gl.createBuffer();
+    const buffer2 = gl.createBuffer();
     const size = uniformsGroup.__size;
     const usage = uniformsGroup.usage;
-    gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
+    gl.bindBuffer(gl.UNIFORM_BUFFER, buffer2);
     gl.bufferData(gl.UNIFORM_BUFFER, size, usage);
     gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPointIndex, buffer);
-    return buffer;
+    gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPointIndex, buffer2);
+    return buffer2;
   }
   function allocateBindingPointIndex() {
     for (let i = 0; i < maxBindingPoints; i++) {
@@ -25024,10 +25024,10 @@ function WebGLUniformsGroups(gl, info, capabilities, state) {
     return 0;
   }
   function updateBufferData(uniformsGroup) {
-    const buffer = buffers[uniformsGroup.id];
+    const buffer2 = buffers[uniformsGroup.id];
     const uniforms = uniformsGroup.uniforms;
     const cache = uniformsGroup.__cache;
-    gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
+    gl.bindBuffer(gl.UNIFORM_BUFFER, buffer2);
     for (let i = 0, il = uniforms.length; i < il; i++) {
       const uniformArray = Array.isArray(uniforms[i]) ? uniforms[i] : [uniforms[i]];
       for (let j = 0, jl = uniformArray.length; j < jl; j++) {
@@ -26416,7 +26416,7 @@ class WebGLRenderer {
       }
       _currentMaterialId = -1;
     };
-    this.readRenderTargetPixels = function(renderTarget, x, y, width, height, buffer, activeCubeFaceIndex, textureIndex = 0) {
+    this.readRenderTargetPixels = function(renderTarget, x, y, width, height, buffer2, activeCubeFaceIndex, textureIndex = 0) {
       if (!(renderTarget && renderTarget.isWebGLRenderTarget)) {
         console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");
         return;
@@ -26441,7 +26441,7 @@ class WebGLRenderer {
           }
           if (x >= 0 && x <= renderTarget.width - width && (y >= 0 && y <= renderTarget.height - height)) {
             if (renderTarget.textures.length > 1) _gl.readBuffer(_gl.COLOR_ATTACHMENT0 + textureIndex);
-            _gl.readPixels(x, y, width, height, utils.convert(textureFormat), utils.convert(textureType), buffer);
+            _gl.readPixels(x, y, width, height, utils.convert(textureFormat), utils.convert(textureType), buffer2);
           }
         } finally {
           const framebuffer2 = _currentRenderTarget !== null ? properties.get(_currentRenderTarget).__webglFramebuffer : null;
@@ -26449,7 +26449,7 @@ class WebGLRenderer {
         }
       }
     };
-    this.readRenderTargetPixelsAsync = async function(renderTarget, x, y, width, height, buffer, activeCubeFaceIndex, textureIndex = 0) {
+    this.readRenderTargetPixelsAsync = async function(renderTarget, x, y, width, height, buffer2, activeCubeFaceIndex, textureIndex = 0) {
       if (!(renderTarget && renderTarget.isWebGLRenderTarget)) {
         throw new Error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");
       }
@@ -26471,7 +26471,7 @@ class WebGLRenderer {
           }
           const glBuffer = _gl.createBuffer();
           _gl.bindBuffer(_gl.PIXEL_PACK_BUFFER, glBuffer);
-          _gl.bufferData(_gl.PIXEL_PACK_BUFFER, buffer.byteLength, _gl.STREAM_READ);
+          _gl.bufferData(_gl.PIXEL_PACK_BUFFER, buffer2.byteLength, _gl.STREAM_READ);
           if (renderTarget.textures.length > 1) _gl.readBuffer(_gl.COLOR_ATTACHMENT0 + textureIndex);
           _gl.readPixels(x, y, width, height, utils.convert(textureFormat), utils.convert(textureType), 0);
           const currFramebuffer = _currentRenderTarget !== null ? properties.get(_currentRenderTarget).__webglFramebuffer : null;
@@ -26480,10 +26480,10 @@ class WebGLRenderer {
           _gl.flush();
           await probeAsync(_gl, sync, 4);
           _gl.bindBuffer(_gl.PIXEL_PACK_BUFFER, glBuffer);
-          _gl.getBufferSubData(_gl.PIXEL_PACK_BUFFER, 0, buffer);
+          _gl.getBufferSubData(_gl.PIXEL_PACK_BUFFER, 0, buffer2);
           _gl.deleteBuffer(glBuffer);
           _gl.deleteSync(sync);
-          return buffer;
+          return buffer2;
         } else {
           throw new Error("THREE.WebGLRenderer.readRenderTargetPixelsAsync: requested read bounds are out of range.");
         }
@@ -26705,9 +26705,9 @@ class SimpleView {
   viewOffset;
   bitOffset = 0;
   buffer;
-  constructor(buffer) {
-    this.view = new DataView(buffer);
-    this.buffer = buffer;
+  constructor(buffer2) {
+    this.view = new DataView(buffer2);
+    this.buffer = buffer2;
     this.viewOffset = 0;
   }
   readBits(n) {
@@ -26749,9 +26749,9 @@ class SimpleView {
     }
   }
   readBuffer(bufferLength) {
-    const buffer = new Uint8Array(this.view.buffer).slice(this.viewOffset, this.viewOffset + bufferLength);
+    const buffer2 = new Uint8Array(this.view.buffer).slice(this.viewOffset, this.viewOffset + bufferLength);
     this.viewOffset += bufferLength;
-    return buffer;
+    return buffer2;
   }
   readUtf8String(stringLength) {
     if (!stringLength) {
@@ -26848,19 +26848,12 @@ class SimpleView {
     return value;
   }
 }
-function bitsToFloat32(bitString) {
-  bitString = bitString.padStart(32, "0").slice(-32);
-  for (let i = 0; i < 32; ++i) {
-    if (bitString[i] !== "0" && bitString[i] !== "1") {
-      throw new Error("A 32-bit string is expected.");
-    }
-  }
-  const buffer = new ArrayBuffer(4);
-  const uint8View = new Uint8Array(buffer);
-  for (let i = 32, byteIndex = 0; i > 0; i -= 8) {
-    uint8View[byteIndex++] = parseInt(bitString.substring(i - 8, i), 2);
-  }
-  return new Float32Array(buffer)[0];
+const buffer = new ArrayBuffer(4);
+const uint32View = new Uint32Array(buffer);
+const float32View = new Float32Array(buffer);
+function bitsToFloat32(value) {
+  uint32View[0] = value >>> 0;
+  return float32View[0];
 }
 function untransformInt32(num) {
   if (num % 2 === 0) {
@@ -26901,9 +26894,9 @@ class RBXSimpleView {
   viewOffset;
   buffer;
   locked = false;
-  constructor(buffer) {
-    this.view = new DataView(buffer);
-    this.buffer = buffer;
+  constructor(buffer2) {
+    this.view = new DataView(buffer2);
+    this.buffer = buffer2;
     this.viewOffset = 0;
   }
   lock() {
@@ -26954,10 +26947,9 @@ class RBXSimpleView {
   readFloat32(littleEndian = true) {
     this.lockCheck();
     const value = this.view.getUint32(this.viewOffset, littleEndian);
-    const bitsValue = value.toString(2).padStart(32, "0");
-    const signBit = bitsValue.at(31);
-    const newBitsValue = signBit + bitsValue.substring(0, 31);
-    const valueFloat = bitsToFloat32(newBitsValue);
+    const signBit = value & 1;
+    const valueTransformed = value >>> 1 | signBit << 31;
+    const valueFloat = bitsToFloat32(valueTransformed);
     this.viewOffset += 4;
     return valueFloat;
   }
@@ -31159,19 +31151,19 @@ class RBX {
     }
     this.treeGenerated = true;
   }
-  fromBuffer(buffer) {
+  fromBuffer(buffer2) {
     this.reset();
-    const view = new RBXSimpleView(buffer);
+    const view = new RBXSimpleView(buffer2);
     const readMagic = view.readUtf8String(magic.length);
     if (readMagic !== magic) {
       if (readMagic === xmlMagic) {
-        const xmlString = new TextDecoder("utf-8").decode(buffer);
+        const xmlString = new TextDecoder("utf-8").decode(buffer2);
         const xml = new DOMParser().parseFromString(xmlString, "text/xml");
         this.xmlString = xmlString;
         this.fromXML(xml);
         return;
       } else {
-        error(buffer);
+        error(buffer2);
         throw new Error("Not a valid file, missing magic");
       }
     }
@@ -31180,7 +31172,7 @@ class RBX {
     this.classCount = view.readInt32();
     this.instanceCount = view.readInt32();
     view.viewOffset += 8;
-    log(false, `FILESIZE: ${buffer.byteLength}, CLASSCOUNT: ${this.classCount}, INSTCOUNT: ${this.instanceCount}`);
+    log(false, `FILESIZE: ${buffer2.byteLength}, CLASSCOUNT: ${this.classCount}, INSTCOUNT: ${this.instanceCount}`);
     let timeout = 0;
     let foundEnd = false;
     while (!foundEnd) {
@@ -31369,8 +31361,8 @@ class RBX {
         }
       }
     }
-    const buffer = new ArrayBuffer(bufferLength);
-    const view = new RBXSimpleView(buffer);
+    const buffer2 = new ArrayBuffer(bufferLength);
+    const view = new RBXSimpleView(buffer2);
     view.writeUtf8String("<roblox", false);
     view.writeUint32(168689545);
     view.writeUint16(2586);
@@ -31391,7 +31383,7 @@ class RBX {
         view.writeUint32(referent);
       }
     }
-    return buffer;
+    return buffer2;
   }
   generateTree() {
     if (this.treeGenerated) {
@@ -31646,9 +31638,9 @@ function rgbToHex(r, g, b) {
   }
   return ("" + componentToHex(r) + componentToHex(g) + componentToHex(b)).toUpperCase();
 }
-function arrayBufferToBase64(buffer) {
+function arrayBufferToBase64(buffer2) {
   let binary = "";
-  const bytes = new Uint8Array(buffer);
+  const bytes = new Uint8Array(buffer2);
   const len = bytes.byteLength;
   for (let i = 0; i < len; i++) {
     binary += String.fromCharCode(bytes[i]);
@@ -33160,8 +33152,8 @@ class Outfit {
     }
     return true;
   }
-  async fromBuffer(buffer, auth) {
-    const view = new SimpleView(buffer);
+  async fromBuffer(buffer2, auth) {
+    const view = new SimpleView(buffer2);
     const outfitFlags = view.readUint8();
     const allSameColor = !!(outfitFlags & 2);
     const hasCreatorId = !!(outfitFlags & 4);
@@ -33329,8 +33321,8 @@ class Outfit {
       if (scale) bufferSize += 3;
       if (headShape !== void 0) bufferSize += 4 + headShape.length;
     }
-    const buffer = new ArrayBuffer(bufferSize);
-    const view = new SimpleView(buffer);
+    const buffer2 = new ArrayBuffer(bufferSize);
+    const view = new SimpleView(buffer2);
     let outfitFlags = 0;
     if (this.playerAvatarType === AvatarType.R15) outfitFlags += 1;
     if (allSameColor) outfitFlags += 2;
@@ -34462,11 +34454,11 @@ class FileMesh {
     } else if (version === 2) {
       log(false, "COREMESH v2");
       const dracoBitStreamSize = view.readUint32();
-      const buffer = view.buffer.slice(view.viewOffset, view.viewOffset + dracoBitStreamSize);
+      const buffer2 = view.buffer.slice(view.viewOffset, view.viewOffset + dracoBitStreamSize);
       const decoderModule = await DracoDecoderModule();
       const decoder = new decoderModule.Decoder();
       const mesh = new decoderModule.Mesh();
-      const status = decoder.DecodeArrayToMesh(new Int8Array(buffer), dracoBitStreamSize, mesh);
+      const status = decoder.DecodeArrayToMesh(new Int8Array(buffer2), dracoBitStreamSize, mesh);
       if (!status.ok() || mesh.ptr === 0) {
         throw new Error("Draco decode failed");
       }
@@ -34543,9 +34535,9 @@ class FileMesh {
     view.readUint32();
     this.facs = readFACS(view);
   }
-  async fromBuffer(buffer) {
+  async fromBuffer(buffer2) {
     this.reset();
-    const view = new SimpleView(buffer);
+    const view = new SimpleView(buffer2);
     const version = view.readUtf8String(13);
     this.version = version;
     switch (version) {
@@ -34553,7 +34545,7 @@ class FileMesh {
       case "version 1.00\n":
       case "version 1.01\r":
       case "version 1.01\n": {
-        const bufferAsLines = new TextDecoder().decode(buffer).split("\n");
+        const bufferAsLines = new TextDecoder().decode(buffer2).split("\n");
         this.coreMesh.numfaces = Number(bufferAsLines[1]);
         this.coreMesh.numverts = this.coreMesh.numfaces * 3;
         const vertData = bufferAsLines[2].replaceAll("[", "").split("]");
@@ -35701,9 +35693,9 @@ const API = {
         }
         const response = await this.GetAssetBuffer(fetchStr, headers, extraStr);
         if (response instanceof ArrayBuffer) {
-          const buffer = response;
+          const buffer2 = response;
           const rbx = new RBX();
-          rbx.fromBuffer(buffer);
+          rbx.fromBuffer(buffer2);
           if (FLAGS.ENABLE_API_CACHE && FLAGS.ENABLE_API_RBX_CACHE) {
             CACHE.RBX.set(cacheStr, rbx.clone());
           }
@@ -35729,9 +35721,9 @@ const API = {
       } else {
         const response = await this.GetAssetBuffer(fetchStr, headers);
         if (response instanceof ArrayBuffer) {
-          const buffer = response;
+          const buffer2 = response;
           const mesh = new FileMesh();
-          await mesh.fromBuffer(buffer);
+          await mesh.fromBuffer(buffer2);
           if (FLAGS.ENABLE_API_CACHE && FLAGS.ENABLE_API_MESH_CACHE) {
             CACHE.Mesh.set(cacheStr, mesh.clone());
           }
@@ -37899,11 +37891,11 @@ class GLTFWriter {
    * @param {ArrayBuffer} buffer
    * @return {0}
    */
-  processBuffer(buffer) {
+  processBuffer(buffer2) {
     const json = this.json;
     const buffers = this.buffers;
     if (!json.buffers) json.buffers = [{ byteLength: 0 }];
-    buffers.push(buffer);
+    buffers.push(buffer2);
     return 0;
   }
   /**
@@ -38003,13 +37995,13 @@ class GLTFWriter {
       const reader = new FileReader();
       reader.readAsArrayBuffer(blob2);
       reader.onloadend = function() {
-        const buffer = getPaddedArrayBuffer(reader.result);
+        const buffer2 = getPaddedArrayBuffer(reader.result);
         const bufferViewDef = {
-          buffer: writer.processBuffer(buffer),
+          buffer: writer.processBuffer(buffer2),
           byteOffset: writer.byteOffset,
-          byteLength: buffer.byteLength
+          byteLength: buffer2.byteLength
         };
-        writer.byteOffset += buffer.byteLength;
+        writer.byteOffset += buffer2.byteLength;
         resolve(json.bufferViews.push(bufferViewDef) - 1);
       };
     });
@@ -48723,8 +48715,8 @@ class SoundWrapper extends InstanceWrapper {
       if (audioUrl && audioUrl.length > 0) {
         API.Asset.GetAssetBuffer(audioUrl).then((responseBuffer) => {
           if (responseBuffer instanceof Response || !this.data.audioContext) return;
-          const buffer = responseBuffer.slice(0);
-          this.data.audioContext.decodeAudioData(buffer).then((decodedData) => {
+          const buffer2 = responseBuffer.slice(0);
+          this.data.audioContext.decodeAudioData(buffer2).then((decodedData) => {
             if (!this.data.audioContext || !this.data.gainNode) return;
             this.data.buffer = decodedData;
             this.playSource();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roavatar-renderer",
-  "version": "1.2.13",
+  "version": "1.2.14",
   "description": "A renderer for Roblox avatars, used by the RoAvatar extension.",
   "author": "steinan",
   "type": "module",