roavatar-renderer 1.5.15 → 1.5.17

package/dist/index.js

@@ -1117,6 +1117,11 @@ const RED_GREEN_RGTC2_Format = 36285;
 const SIGNED_RED_GREEN_RGTC2_Format = 36286;
 const InterpolateDiscrete = 2300;
 const InterpolateLinear = 2301;
+const InterpolateSmooth = 2302;
+const ZeroCurvatureEnding = 2400;
+const ZeroSlopeEnding = 2401;
+const WrapAroundEnding = 2402;
+const NormalAnimationBlendMode = 2500;
 const BasicDepthPacking = 3200;
 const RGBADepthPacking = 3201;
 const TangentSpaceNormalMap = 0;
@@ -15538,6 +15543,1128 @@ class MeshDistanceMaterial extends Material {
     return this;
   }
 }
+function convertArray(array, type) {
+  if (!array || array.constructor === type) return array;
+  if (typeof type.BYTES_PER_ELEMENT === "number") {
+    return new type(array);
+  }
+  return Array.prototype.slice.call(array);
+}
+function isTypedArray(object) {
+  return ArrayBuffer.isView(object) && !(object instanceof DataView);
+}
+function getKeyframeOrder(times) {
+  function compareTime(i, j) {
+    return times[i] - times[j];
+  }
+  const n = times.length;
+  const result = new Array(n);
+  for (let i = 0; i !== n; ++i) result[i] = i;
+  result.sort(compareTime);
+  return result;
+}
+function sortedArray(values, stride, order) {
+  const nValues = values.length;
+  const result = new values.constructor(nValues);
+  for (let i = 0, dstOffset = 0; dstOffset !== nValues; ++i) {
+    const srcOffset = order[i] * stride;
+    for (let j = 0; j !== stride; ++j) {
+      result[dstOffset++] = values[srcOffset + j];
+    }
+  }
+  return result;
+}
+function flattenJSON(jsonKeys, times, values, valuePropertyName) {
+  let i = 1, key = jsonKeys[0];
+  while (key !== void 0 && key[valuePropertyName] === void 0) {
+    key = jsonKeys[i++];
+  }
+  if (key === void 0) return;
+  let value = key[valuePropertyName];
+  if (value === void 0) return;
+  if (Array.isArray(value)) {
+    do {
+      value = key[valuePropertyName];
+      if (value !== void 0) {
+        times.push(key.time);
+        values.push(...value);
+      }
+      key = jsonKeys[i++];
+    } while (key !== void 0);
+  } else if (value.toArray !== void 0) {
+    do {
+      value = key[valuePropertyName];
+      if (value !== void 0) {
+        times.push(key.time);
+        value.toArray(values, values.length);
+      }
+      key = jsonKeys[i++];
+    } while (key !== void 0);
+  } else {
+    do {
+      value = key[valuePropertyName];
+      if (value !== void 0) {
+        times.push(key.time);
+        values.push(value);
+      }
+      key = jsonKeys[i++];
+    } while (key !== void 0);
+  }
+}
+class Interpolant {
+  /**
+   * Constructs a new interpolant.
+   *
+   * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
+   * @param {TypedArray} sampleValues - The sample values.
+   * @param {number} sampleSize - The sample size
+   * @param {TypedArray} [resultBuffer] - The result buffer.
+   */
+  constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) {
+    this.parameterPositions = parameterPositions;
+    this._cachedIndex = 0;
+    this.resultBuffer = resultBuffer !== void 0 ? resultBuffer : new sampleValues.constructor(sampleSize);
+    this.sampleValues = sampleValues;
+    this.valueSize = sampleSize;
+    this.settings = null;
+    this.DefaultSettings_ = {};
+  }
+  /**
+   * Evaluate the interpolant at position `t`.
+   *
+   * @param {number} t - The interpolation factor.
+   * @return {TypedArray} The result buffer.
+   */
+  evaluate(t) {
+    const pp = this.parameterPositions;
+    let i1 = this._cachedIndex, t1 = pp[i1], t0 = pp[i1 - 1];
+    validate_interval: {
+      seek: {
+        let right;
+        linear_scan: {
+          forward_scan: if (!(t < t1)) {
+            for (let giveUpAt = i1 + 2; ; ) {
+              if (t1 === void 0) {
+                if (t < t0) break forward_scan;
+                i1 = pp.length;
+                this._cachedIndex = i1;
+                return this.copySampleValue_(i1 - 1);
+              }
+              if (i1 === giveUpAt) break;
+              t0 = t1;
+              t1 = pp[++i1];
+              if (t < t1) {
+                break seek;
+              }
+            }
+            right = pp.length;
+            break linear_scan;
+          }
+          if (!(t >= t0)) {
+            const t1global = pp[1];
+            if (t < t1global) {
+              i1 = 2;
+              t0 = t1global;
+            }
+            for (let giveUpAt = i1 - 2; ; ) {
+              if (t0 === void 0) {
+                this._cachedIndex = 0;
+                return this.copySampleValue_(0);
+              }
+              if (i1 === giveUpAt) break;
+              t1 = t0;
+              t0 = pp[--i1 - 1];
+              if (t >= t0) {
+                break seek;
+              }
+            }
+            right = i1;
+            i1 = 0;
+            break linear_scan;
+          }
+          break validate_interval;
+        }
+        while (i1 < right) {
+          const mid = i1 + right >>> 1;
+          if (t < pp[mid]) {
+            right = mid;
+          } else {
+            i1 = mid + 1;
+          }
+        }
+        t1 = pp[i1];
+        t0 = pp[i1 - 1];
+        if (t0 === void 0) {
+          this._cachedIndex = 0;
+          return this.copySampleValue_(0);
+        }
+        if (t1 === void 0) {
+          i1 = pp.length;
+          this._cachedIndex = i1;
+          return this.copySampleValue_(i1 - 1);
+        }
+      }
+      this._cachedIndex = i1;
+      this.intervalChanged_(i1, t0, t1);
+    }
+    return this.interpolate_(i1, t0, t, t1);
+  }
+  /**
+   * Returns the interpolation settings.
+   *
+   * @return {Object} The interpolation settings.
+   */
+  getSettings_() {
+    return this.settings || this.DefaultSettings_;
+  }
+  /**
+   * Copies a sample value to the result buffer.
+   *
+   * @param {number} index - An index into the sample value buffer.
+   * @return {TypedArray} The result buffer.
+   */
+  copySampleValue_(index) {
+    const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, offset = index * stride;
+    for (let i = 0; i !== stride; ++i) {
+      result[i] = values[offset + i];
+    }
+    return result;
+  }
+  /**
+   * Copies a sample value to the result buffer.
+   *
+   * @abstract
+   * @param {number} i1 - An index into the sample value buffer.
+   * @param {number} t0 - The previous interpolation factor.
+   * @param {number} t - The current interpolation factor.
+   * @param {number} t1 - The next interpolation factor.
+   * @return {TypedArray} The result buffer.
+   */
+  interpolate_() {
+    throw new Error("call to abstract method");
+  }
+  /**
+   * Optional method that is executed when the interval has changed.
+   *
+   * @param {number} i1 - An index into the sample value buffer.
+   * @param {number} t0 - The previous interpolation factor.
+   * @param {number} t - The current interpolation factor.
+   */
+  intervalChanged_() {
+  }
+}
+class CubicInterpolant extends Interpolant {
+  /**
+   * Constructs a new cubic interpolant.
+   *
+   * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
+   * @param {TypedArray} sampleValues - The sample values.
+   * @param {number} sampleSize - The sample size
+   * @param {TypedArray} [resultBuffer] - The result buffer.
+   */
+  constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) {
+    super(parameterPositions, sampleValues, sampleSize, resultBuffer);
+    this._weightPrev = -0;
+    this._offsetPrev = -0;
+    this._weightNext = -0;
+    this._offsetNext = -0;
+    this.DefaultSettings_ = {
+      endingStart: ZeroCurvatureEnding,
+      endingEnd: ZeroCurvatureEnding
+    };
+  }
+  intervalChanged_(i1, t0, t1) {
+    const pp = this.parameterPositions;
+    let iPrev = i1 - 2, iNext = i1 + 1, tPrev = pp[iPrev], tNext = pp[iNext];
+    if (tPrev === void 0) {
+      switch (this.getSettings_().endingStart) {
+        case ZeroSlopeEnding:
+          iPrev = i1;
+          tPrev = 2 * t0 - t1;
+          break;
+        case WrapAroundEnding:
+          iPrev = pp.length - 2;
+          tPrev = t0 + pp[iPrev] - pp[iPrev + 1];
+          break;
+        default:
+          iPrev = i1;
+          tPrev = t1;
+      }
+    }
+    if (tNext === void 0) {
+      switch (this.getSettings_().endingEnd) {
+        case ZeroSlopeEnding:
+          iNext = i1;
+          tNext = 2 * t1 - t0;
+          break;
+        case WrapAroundEnding:
+          iNext = 1;
+          tNext = t1 + pp[1] - pp[0];
+          break;
+        default:
+          iNext = i1 - 1;
+          tNext = t0;
+      }
+    }
+    const halfDt = (t1 - t0) * 0.5, stride = this.valueSize;
+    this._weightPrev = halfDt / (t0 - tPrev);
+    this._weightNext = halfDt / (tNext - t1);
+    this._offsetPrev = iPrev * stride;
+    this._offsetNext = iNext * stride;
+  }
+  interpolate_(i1, t0, t, t1) {
+    const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, o1 = i1 * stride, o0 = o1 - stride, oP = this._offsetPrev, oN = this._offsetNext, wP = this._weightPrev, wN = this._weightNext, p2 = (t - t0) / (t1 - t0), pp = p2 * p2, ppp = pp * p2;
+    const sP = -wP * ppp + 2 * wP * pp - wP * p2;
+    const s0 = (1 + wP) * ppp + (-1.5 - 2 * wP) * pp + (-0.5 + wP) * p2 + 1;
+    const s1 = (-1 - wN) * ppp + (1.5 + wN) * pp + 0.5 * p2;
+    const sN = wN * ppp - wN * pp;
+    for (let i = 0; i !== stride; ++i) {
+      result[i] = sP * values[oP + i] + s0 * values[o0 + i] + s1 * values[o1 + i] + sN * values[oN + i];
+    }
+    return result;
+  }
+}
+class LinearInterpolant extends Interpolant {
+  /**
+   * Constructs a new linear interpolant.
+   *
+   * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
+   * @param {TypedArray} sampleValues - The sample values.
+   * @param {number} sampleSize - The sample size
+   * @param {TypedArray} [resultBuffer] - The result buffer.
+   */
+  constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) {
+    super(parameterPositions, sampleValues, sampleSize, resultBuffer);
+  }
+  interpolate_(i1, t0, t, t1) {
+    const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, offset1 = i1 * stride, offset0 = offset1 - stride, weight1 = (t - t0) / (t1 - t0), weight0 = 1 - weight1;
+    for (let i = 0; i !== stride; ++i) {
+      result[i] = values[offset0 + i] * weight0 + values[offset1 + i] * weight1;
+    }
+    return result;
+  }
+}
+class DiscreteInterpolant extends Interpolant {
+  /**
+   * Constructs a new discrete interpolant.
+   *
+   * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
+   * @param {TypedArray} sampleValues - The sample values.
+   * @param {number} sampleSize - The sample size
+   * @param {TypedArray} [resultBuffer] - The result buffer.
+   */
+  constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) {
+    super(parameterPositions, sampleValues, sampleSize, resultBuffer);
+  }
+  interpolate_(i1) {
+    return this.copySampleValue_(i1 - 1);
+  }
+}
+class KeyframeTrack {
+  /**
+   * Constructs a new keyframe track.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<number|string|boolean>} values - A list of keyframe values.
+   * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
+   */
+  constructor(name, times, values, interpolation) {
+    if (name === void 0) throw new Error("THREE.KeyframeTrack: track name is undefined");
+    if (times === void 0 || times.length === 0) throw new Error("THREE.KeyframeTrack: no keyframes in track named " + name);
+    this.name = name;
+    this.times = convertArray(times, this.TimeBufferType);
+    this.values = convertArray(values, this.ValueBufferType);
+    this.setInterpolation(interpolation || this.DefaultInterpolation);
+  }
+  /**
+   * Converts the keyframe track to JSON.
+   *
+   * @static
+   * @param {KeyframeTrack} track - The keyframe track to serialize.
+   * @return {Object} The serialized keyframe track as JSON.
+   */
+  static toJSON(track) {
+    const trackType = track.constructor;
+    let json;
+    if (trackType.toJSON !== this.toJSON) {
+      json = trackType.toJSON(track);
+    } else {
+      json = {
+        "name": track.name,
+        "times": convertArray(track.times, Array),
+        "values": convertArray(track.values, Array)
+      };
+      const interpolation = track.getInterpolation();
+      if (interpolation !== track.DefaultInterpolation) {
+        json.interpolation = interpolation;
+      }
+    }
+    json.type = track.ValueTypeName;
+    return json;
+  }
+  /**
+   * Factory method for creating a new discrete interpolant.
+   *
+   * @static
+   * @param {TypedArray} [result] - The result buffer.
+   * @return {DiscreteInterpolant} The new interpolant.
+   */
+  InterpolantFactoryMethodDiscrete(result) {
+    return new DiscreteInterpolant(this.times, this.values, this.getValueSize(), result);
+  }
+  /**
+   * Factory method for creating a new linear interpolant.
+   *
+   * @static
+   * @param {TypedArray} [result] - The result buffer.
+   * @return {LinearInterpolant} The new interpolant.
+   */
+  InterpolantFactoryMethodLinear(result) {
+    return new LinearInterpolant(this.times, this.values, this.getValueSize(), result);
+  }
+  /**
+   * Factory method for creating a new smooth interpolant.
+   *
+   * @static
+   * @param {TypedArray} [result] - The result buffer.
+   * @return {CubicInterpolant} The new interpolant.
+   */
+  InterpolantFactoryMethodSmooth(result) {
+    return new CubicInterpolant(this.times, this.values, this.getValueSize(), result);
+  }
+  /**
+   * Defines the interpolation factor method for this keyframe track.
+   *
+   * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} interpolation - The interpolation type.
+   * @return {KeyframeTrack} A reference to this keyframe track.
+   */
+  setInterpolation(interpolation) {
+    let factoryMethod;
+    switch (interpolation) {
+      case InterpolateDiscrete:
+        factoryMethod = this.InterpolantFactoryMethodDiscrete;
+        break;
+      case InterpolateLinear:
+        factoryMethod = this.InterpolantFactoryMethodLinear;
+        break;
+      case InterpolateSmooth:
+        factoryMethod = this.InterpolantFactoryMethodSmooth;
+        break;
+    }
+    if (factoryMethod === void 0) {
+      const message = "unsupported interpolation for " + this.ValueTypeName + " keyframe track named " + this.name;
+      if (this.createInterpolant === void 0) {
+        if (interpolation !== this.DefaultInterpolation) {
+          this.setInterpolation(this.DefaultInterpolation);
+        } else {
+          throw new Error(message);
+        }
+      }
+      console.warn("THREE.KeyframeTrack:", message);
+      return this;
+    }
+    this.createInterpolant = factoryMethod;
+    return this;
+  }
+  /**
+   * Returns the current interpolation type.
+   *
+   * @return {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} The interpolation type.
+   */
+  getInterpolation() {
+    switch (this.createInterpolant) {
+      case this.InterpolantFactoryMethodDiscrete:
+        return InterpolateDiscrete;
+      case this.InterpolantFactoryMethodLinear:
+        return InterpolateLinear;
+      case this.InterpolantFactoryMethodSmooth:
+        return InterpolateSmooth;
+    }
+  }
+  /**
+   * Returns the value size.
+   *
+   * @return {number} The value size.
+   */
+  getValueSize() {
+    return this.values.length / this.times.length;
+  }
+  /**
+   * Moves all keyframes either forward or backward in time.
+   *
+   * @param {number} timeOffset - The offset to move the time values.
+   * @return {KeyframeTrack} A reference to this keyframe track.
+   */
+  shift(timeOffset) {
+    if (timeOffset !== 0) {
+      const times = this.times;
+      for (let i = 0, n = times.length; i !== n; ++i) {
+        times[i] += timeOffset;
+      }
+    }
+    return this;
+  }
+  /**
+   * Scale all keyframe times by a factor (useful for frame - seconds conversions).
+   *
+   * @param {number} timeScale - The time scale.
+   * @return {KeyframeTrack} A reference to this keyframe track.
+   */
+  scale(timeScale) {
+    if (timeScale !== 1) {
+      const times = this.times;
+      for (let i = 0, n = times.length; i !== n; ++i) {
+        times[i] *= timeScale;
+      }
+    }
+    return this;
+  }
+  /**
+   * Removes keyframes before and after animation without changing any values within the defined time range.
+   *
+   * Note: The method does not shift around keys to the start of the track time, because for interpolated
+   * keys this will change their values
+   *
+   * @param {number} startTime - The start time.
+   * @param {number} endTime - The end time.
+   * @return {KeyframeTrack} A reference to this keyframe track.
+   */
+  trim(startTime, endTime) {
+    const times = this.times, nKeys = times.length;
+    let from = 0, to = nKeys - 1;
+    while (from !== nKeys && times[from] < startTime) {
+      ++from;
+    }
+    while (to !== -1 && times[to] > endTime) {
+      --to;
+    }
+    ++to;
+    if (from !== 0 || to !== nKeys) {
+      if (from >= to) {
+        to = Math.max(to, 1);
+        from = to - 1;
+      }
+      const stride = this.getValueSize();
+      this.times = times.slice(from, to);
+      this.values = this.values.slice(from * stride, to * stride);
+    }
+    return this;
+  }
+  /**
+   * Performs minimal validation on the keyframe track. Returns `true` if the values
+   * are valid.
+   *
+   * @return {boolean} Whether the keyframes are valid or not.
+   */
+  validate() {
+    let valid = true;
+    const valueSize = this.getValueSize();
+    if (valueSize - Math.floor(valueSize) !== 0) {
+      console.error("THREE.KeyframeTrack: Invalid value size in track.", this);
+      valid = false;
+    }
+    const times = this.times, values = this.values, nKeys = times.length;
+    if (nKeys === 0) {
+      console.error("THREE.KeyframeTrack: Track is empty.", this);
+      valid = false;
+    }
+    let prevTime = null;
+    for (let i = 0; i !== nKeys; i++) {
+      const currTime = times[i];
+      if (typeof currTime === "number" && isNaN(currTime)) {
+        console.error("THREE.KeyframeTrack: Time is not a valid number.", this, i, currTime);
+        valid = false;
+        break;
+      }
+      if (prevTime !== null && prevTime > currTime) {
+        console.error("THREE.KeyframeTrack: Out of order keys.", this, i, currTime, prevTime);
+        valid = false;
+        break;
+      }
+      prevTime = currTime;
+    }
+    if (values !== void 0) {
+      if (isTypedArray(values)) {
+        for (let i = 0, n = values.length; i !== n; ++i) {
+          const value = values[i];
+          if (isNaN(value)) {
+            console.error("THREE.KeyframeTrack: Value is not a valid number.", this, i, value);
+            valid = false;
+            break;
+          }
+        }
+      }
+    }
+    return valid;
+  }
+  /**
+   * Optimizes this keyframe track by removing equivalent sequential keys (which are
+   * common in morph target sequences).
+   *
+   * @return {AnimationClip} A reference to this animation clip.
+   */
+  optimize() {
+    const times = this.times.slice(), values = this.values.slice(), stride = this.getValueSize(), smoothInterpolation = this.getInterpolation() === InterpolateSmooth, lastIndex = times.length - 1;
+    let writeIndex = 1;
+    for (let i = 1; i < lastIndex; ++i) {
+      let keep = false;
+      const time2 = times[i];
+      const timeNext = times[i + 1];
+      if (time2 !== timeNext && (i !== 1 || time2 !== times[0])) {
+        if (!smoothInterpolation) {
+          const offset = i * stride, offsetP = offset - stride, offsetN = offset + stride;
+          for (let j = 0; j !== stride; ++j) {
+            const value = values[offset + j];
+            if (value !== values[offsetP + j] || value !== values[offsetN + j]) {
+              keep = true;
+              break;
+            }
+          }
+        } else {
+          keep = true;
+        }
+      }
+      if (keep) {
+        if (i !== writeIndex) {
+          times[writeIndex] = times[i];
+          const readOffset = i * stride, writeOffset = writeIndex * stride;
+          for (let j = 0; j !== stride; ++j) {
+            values[writeOffset + j] = values[readOffset + j];
+          }
+        }
+        ++writeIndex;
+      }
+    }
+    if (lastIndex > 0) {
+      times[writeIndex] = times[lastIndex];
+      for (let readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++j) {
+        values[writeOffset + j] = values[readOffset + j];
+      }
+      ++writeIndex;
+    }
+    if (writeIndex !== times.length) {
+      this.times = times.slice(0, writeIndex);
+      this.values = values.slice(0, writeIndex * stride);
+    } else {
+      this.times = times;
+      this.values = values;
+    }
+    return this;
+  }
+  /**
+   * Returns a new keyframe track with copied values from this instance.
+   *
+   * @return {KeyframeTrack} A clone of this instance.
+   */
+  clone() {
+    const times = this.times.slice();
+    const values = this.values.slice();
+    const TypedKeyframeTrack = this.constructor;
+    const track = new TypedKeyframeTrack(this.name, times, values);
+    track.createInterpolant = this.createInterpolant;
+    return track;
+  }
+}
+KeyframeTrack.prototype.ValueTypeName = "";
+KeyframeTrack.prototype.TimeBufferType = Float32Array;
+KeyframeTrack.prototype.ValueBufferType = Float32Array;
+KeyframeTrack.prototype.DefaultInterpolation = InterpolateLinear;
+class BooleanKeyframeTrack extends KeyframeTrack {
+  /**
+   * Constructs a new boolean keyframe track.
+   *
+   * This keyframe track type has no `interpolation` parameter because the
+   * interpolation is always discrete.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<boolean>} values - A list of keyframe values.
+   */
+  constructor(name, times, values) {
+    super(name, times, values);
+  }
+}
+BooleanKeyframeTrack.prototype.ValueTypeName = "bool";
+BooleanKeyframeTrack.prototype.ValueBufferType = Array;
+BooleanKeyframeTrack.prototype.DefaultInterpolation = InterpolateDiscrete;
+BooleanKeyframeTrack.prototype.InterpolantFactoryMethodLinear = void 0;
+BooleanKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = void 0;
+class ColorKeyframeTrack extends KeyframeTrack {
+  /**
+   * Constructs a new color keyframe track.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<number>} values - A list of keyframe values.
+   * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
+   */
+  constructor(name, times, values, interpolation) {
+    super(name, times, values, interpolation);
+  }
+}
+ColorKeyframeTrack.prototype.ValueTypeName = "color";
+class NumberKeyframeTrack extends KeyframeTrack {
+  /**
+   * Constructs a new number keyframe track.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<number>} values - A list of keyframe values.
+   * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
+   */
+  constructor(name, times, values, interpolation) {
+    super(name, times, values, interpolation);
+  }
+}
+NumberKeyframeTrack.prototype.ValueTypeName = "number";
+class QuaternionLinearInterpolant extends Interpolant {
+  /**
+   * Constructs a new SLERP interpolant.
+   *
+   * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
+   * @param {TypedArray} sampleValues - The sample values.
+   * @param {number} sampleSize - The sample size
+   * @param {TypedArray} [resultBuffer] - The result buffer.
+   */
+  constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) {
+    super(parameterPositions, sampleValues, sampleSize, resultBuffer);
+  }
+  interpolate_(i1, t0, t, t1) {
+    const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, alpha = (t - t0) / (t1 - t0);
+    let offset = i1 * stride;
+    for (let end = offset + stride; offset !== end; offset += 4) {
+      Quaternion.slerpFlat(result, 0, values, offset - stride, values, offset, alpha);
+    }
+    return result;
+  }
+}
+class QuaternionKeyframeTrack extends KeyframeTrack {
+  /**
+   * Constructs a new Quaternion keyframe track.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<number>} values - A list of keyframe values.
+   * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
+   */
+  constructor(name, times, values, interpolation) {
+    super(name, times, values, interpolation);
+  }
+  /**
+   * Overwritten so the method returns Quaternion based interpolant.
+   *
+   * @static
+   * @param {TypedArray} [result] - The result buffer.
+   * @return {QuaternionLinearInterpolant} The new interpolant.
+   */
+  InterpolantFactoryMethodLinear(result) {
+    return new QuaternionLinearInterpolant(this.times, this.values, this.getValueSize(), result);
+  }
+}
+QuaternionKeyframeTrack.prototype.ValueTypeName = "quaternion";
+QuaternionKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = void 0;
+class StringKeyframeTrack extends KeyframeTrack {
+  /**
+   * Constructs a new string keyframe track.
+   *
+   * This keyframe track type has no `interpolation` parameter because the
+   * interpolation is always discrete.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<string>} values - A list of keyframe values.
+   */
+  constructor(name, times, values) {
+    super(name, times, values);
+  }
+}
+StringKeyframeTrack.prototype.ValueTypeName = "string";
+StringKeyframeTrack.prototype.ValueBufferType = Array;
+StringKeyframeTrack.prototype.DefaultInterpolation = InterpolateDiscrete;
+StringKeyframeTrack.prototype.InterpolantFactoryMethodLinear = void 0;
+StringKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = void 0;
+class VectorKeyframeTrack extends KeyframeTrack {
+  /**
+   * Constructs a new vector keyframe track.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<number>} values - A list of keyframe values.
+   * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
+   */
+  constructor(name, times, values, interpolation) {
+    super(name, times, values, interpolation);
+  }
+}
+VectorKeyframeTrack.prototype.ValueTypeName = "vector";
+class AnimationClip {
+  /**
+   * Constructs a new animation clip.
+   *
+   * Note: Instead of instantiating an AnimationClip directly with the constructor, you can
+   * use the static interface of this class for creating clips. In most cases though, animation clips
+   * will automatically be created by loaders when importing animated 3D assets.
+   *
+   * @param {string} [name=''] - The clip's name.
+   * @param {number} [duration=-1] - The clip's duration in seconds. If a negative value is passed,
+   * the duration will be calculated from the passed keyframes.
+   * @param {Array<KeyframeTrack>} tracks - An array of keyframe tracks.
+   * @param {(NormalAnimationBlendMode|AdditiveAnimationBlendMode)} [blendMode=NormalAnimationBlendMode] - Defines how the animation
+   * is blended/combined when two or more animations are simultaneously played.
+   */
+  constructor(name = "", duration = -1, tracks = [], blendMode = NormalAnimationBlendMode) {
+    this.name = name;
+    this.tracks = tracks;
+    this.duration = duration;
+    this.blendMode = blendMode;
+    this.uuid = generateUUID();
+    this.userData = {};
+    if (this.duration < 0) {
+      this.resetDuration();
+    }
+  }
+  /**
+   * Factory method for creating an animation clip from the given JSON.
+   *
+   * @static
+   * @param {Object} json - The serialized animation clip.
+   * @return {AnimationClip} The new animation clip.
+   */
+  static parse(json) {
+    const tracks = [], jsonTracks = json.tracks, frameTime = 1 / (json.fps || 1);
+    for (let i = 0, n = jsonTracks.length; i !== n; ++i) {
+      tracks.push(parseKeyframeTrack(jsonTracks[i]).scale(frameTime));
+    }
+    const clip = new this(json.name, json.duration, tracks, json.blendMode);
+    clip.uuid = json.uuid;
+    clip.userData = JSON.parse(json.userData || "{}");
+    return clip;
+  }
+  /**
+   * Serializes the given animation clip into JSON.
+   *
+   * @static
+   * @param {AnimationClip} clip - The animation clip to serialize.
+   * @return {Object} The JSON object.
+   */
+  static toJSON(clip) {
+    const tracks = [], clipTracks = clip.tracks;
+    const json = {
+      "name": clip.name,
+      "duration": clip.duration,
+      "tracks": tracks,
+      "uuid": clip.uuid,
+      "blendMode": clip.blendMode,
+      "userData": JSON.stringify(clip.userData)
+    };
+    for (let i = 0, n = clipTracks.length; i !== n; ++i) {
+      tracks.push(KeyframeTrack.toJSON(clipTracks[i]));
+    }
+    return json;
+  }
+  /**
+   * Returns a new animation clip from the passed morph targets array of a
+   * geometry, taking a name and the number of frames per second.
+   *
+   * Note: The fps parameter is required, but the animation speed can be
+   * overridden via {@link AnimationAction#setDuration}.
+   *
+   * @static
+   * @param {string} name - The name of the animation clip.
+   * @param {Array<Object>} morphTargetSequence - A sequence of morph targets.
+   * @param {number} fps - The Frames-Per-Second value.
+   * @param {boolean} noLoop - Whether the clip should be no loop or not.
+   * @return {AnimationClip} The new animation clip.
+   */
+  static CreateFromMorphTargetSequence(name, morphTargetSequence, fps, noLoop) {
+    const numMorphTargets = morphTargetSequence.length;
+    const tracks = [];
+    for (let i = 0; i < numMorphTargets; i++) {
+      let times = [];
+      let values = [];
+      times.push(
+        (i + numMorphTargets - 1) % numMorphTargets,
+        i,
+        (i + 1) % numMorphTargets
+      );
+      values.push(0, 1, 0);
+      const order = getKeyframeOrder(times);
+      times = sortedArray(times, 1, order);
+      values = sortedArray(values, 1, order);
+      if (!noLoop && times[0] === 0) {
+        times.push(numMorphTargets);
+        values.push(values[0]);
+      }
+      tracks.push(
+        new NumberKeyframeTrack(
+          ".morphTargetInfluences[" + morphTargetSequence[i].name + "]",
+          times,
+          values
+        ).scale(1 / fps)
+      );
+    }
+    return new this(name, -1, tracks);
+  }
+  /**
+   * Searches for an animation clip by name, taking as its first parameter
+   * either an array of clips, or a mesh or geometry that contains an
+   * array named "animations" property.
+   *
+   * @static
+   * @param {(Array<AnimationClip>|Object3D)} objectOrClipArray - The array or object to search through.
+   * @param {string} name - The name to search for.
+   * @return {?AnimationClip} The found animation clip. Returns `null` if no clip has been found.
+   */
+  static findByName(objectOrClipArray, name) {
+    let clipArray = objectOrClipArray;
+    if (!Array.isArray(objectOrClipArray)) {
+      const o = objectOrClipArray;
+      clipArray = o.geometry && o.geometry.animations || o.animations;
+    }
+    for (let i = 0; i < clipArray.length; i++) {
+      if (clipArray[i].name === name) {
+        return clipArray[i];
+      }
+    }
+    return null;
+  }
+  /**
+   * Returns an array of new AnimationClips created from the morph target
+   * sequences of a geometry, trying to sort morph target names into
+   * animation-group-based patterns like "Walk_001, Walk_002, Run_001, Run_002...".
+   *
+   * See {@link MD2Loader#parse} as an example for how the method should be used.
+   *
+   * @static
+   * @param {Array<Object>} morphTargets - A sequence of morph targets.
+   * @param {number} fps - The Frames-Per-Second value.
+   * @param {boolean} noLoop - Whether the clip should be no loop or not.
+   * @return {Array<AnimationClip>} An array of new animation clips.
+   */
+  static CreateClipsFromMorphTargetSequences(morphTargets, fps, noLoop) {
+    const animationToMorphTargets = {};
+    const pattern = /^([\w-]*?)([\d]+)$/;
+    for (let i = 0, il = morphTargets.length; i < il; i++) {
+      const morphTarget = morphTargets[i];
+      const parts = morphTarget.name.match(pattern);
+      if (parts && parts.length > 1) {
+        const name = parts[1];
+        let animationMorphTargets = animationToMorphTargets[name];
+        if (!animationMorphTargets) {
+          animationToMorphTargets[name] = animationMorphTargets = [];
+        }
+        animationMorphTargets.push(morphTarget);
+      }
+    }
+    const clips = [];
+    for (const name in animationToMorphTargets) {
+      clips.push(this.CreateFromMorphTargetSequence(name, animationToMorphTargets[name], fps, noLoop));
+    }
+    return clips;
+  }
+  /**
+   * Parses the `animation.hierarchy` format and returns a new animation clip.
+   *
+   * @static
+   * @deprecated since r175.
+   * @param {Object} animation - A serialized animation clip as JSON.
+   * @param {Array<Bones>} bones - An array of bones.
+   * @return {?AnimationClip} The new animation clip.
+   */
+  static parseAnimation(animation, bones) {
+    console.warn("THREE.AnimationClip: parseAnimation() is deprecated and will be removed with r185");
+    if (!animation) {
+      console.error("THREE.AnimationClip: No animation in JSONLoader data.");
+      return null;
+    }
+    const addNonemptyTrack = function(trackType, trackName, animationKeys, propertyName, destTracks) {
+      if (animationKeys.length !== 0) {
+        const times = [];
+        const values = [];
+        flattenJSON(animationKeys, times, values, propertyName);
+        if (times.length !== 0) {
+          destTracks.push(new trackType(trackName, times, values));
+        }
+      }
+    };
+    const tracks = [];
+    const clipName = animation.name || "default";
+    const fps = animation.fps || 30;
+    const blendMode = animation.blendMode;
+    let duration = animation.length || -1;
+    const hierarchyTracks = animation.hierarchy || [];
+    for (let h = 0; h < hierarchyTracks.length; h++) {
+      const animationKeys = hierarchyTracks[h].keys;
+      if (!animationKeys || animationKeys.length === 0) continue;
+      if (animationKeys[0].morphTargets) {
+        const morphTargetNames = {};
+        let k;
+        for (k = 0; k < animationKeys.length; k++) {
+          if (animationKeys[k].morphTargets) {
+            for (let m = 0; m < animationKeys[k].morphTargets.length; m++) {
+              morphTargetNames[animationKeys[k].morphTargets[m]] = -1;
+            }
+          }
+        }
+        for (const morphTargetName in morphTargetNames) {
+          const times = [];
+          const values = [];
+          for (let m = 0; m !== animationKeys[k].morphTargets.length; ++m) {
+            const animationKey = animationKeys[k];
+            times.push(animationKey.time);
+            values.push(animationKey.morphTarget === morphTargetName ? 1 : 0);
+          }
+          tracks.push(new NumberKeyframeTrack(".morphTargetInfluence[" + morphTargetName + "]", times, values));
+        }
+        duration = morphTargetNames.length * fps;
+      } else {
+        const boneName = ".bones[" + bones[h].name + "]";
+        addNonemptyTrack(
+          VectorKeyframeTrack,
+          boneName + ".position",
+          animationKeys,
+          "pos",
+          tracks
+        );
+        addNonemptyTrack(
+          QuaternionKeyframeTrack,
+          boneName + ".quaternion",
+          animationKeys,
+          "rot",
+          tracks
+        );
+        addNonemptyTrack(
+          VectorKeyframeTrack,
+          boneName + ".scale",
+          animationKeys,
+          "scl",
+          tracks
+        );
+      }
+    }
+    if (tracks.length === 0) {
+      return null;
+    }
+    const clip = new this(clipName, duration, tracks, blendMode);
+    return clip;
+  }
+  /**
+   * Sets the duration of this clip to the duration of its longest keyframe track.
+   *
+   * @return {AnimationClip} A reference to this animation clip.
+   */
+  resetDuration() {
+    const tracks = this.tracks;
+    let duration = 0;
+    for (let i = 0, n = tracks.length; i !== n; ++i) {
+      const track = this.tracks[i];
+      duration = Math.max(duration, track.times[track.times.length - 1]);
+    }
+    this.duration = duration;
+    return this;
+  }
+  /**
+   * Trims all tracks to the clip's duration.
+   *
+   * @return {AnimationClip} A reference to this animation clip.
+   */
+  trim() {
+    for (let i = 0; i < this.tracks.length; i++) {
+      this.tracks[i].trim(0, this.duration);
+    }
+    return this;
+  }
+  /**
+   * Performs minimal validation on each track in the clip. Returns `true` if all
+   * tracks are valid.
+   *
+   * @return {boolean} Whether the clip's keyframes are valid or not.
+   */
+  validate() {
+    let valid = true;
+    for (let i = 0; i < this.tracks.length; i++) {
+      valid = valid && this.tracks[i].validate();
+    }
+    return valid;
+  }
+  /**
+   * Optimizes each track by removing equivalent sequential keys (which are
+   * common in morph target sequences).
+   *
+   * @return {AnimationClip} A reference to this animation clip.
+   */
+  optimize() {
+    for (let i = 0; i < this.tracks.length; i++) {
+      this.tracks[i].optimize();
+    }
+    return this;
+  }
+  /**
+   * Returns a new animation clip with copied values from this instance.
+   *
+   * @return {AnimationClip} A clone of this instance.
+   */
+  clone() {
+    const tracks = [];
+    for (let i = 0; i < this.tracks.length; i++) {
+      tracks.push(this.tracks[i].clone());
+    }
+    const clip = new this.constructor(this.name, this.duration, tracks, this.blendMode);
+    clip.userData = JSON.parse(JSON.stringify(this.userData));
+    return clip;
+  }
+  /**
+   * Serializes this animation clip into JSON.
+   *
+   * @return {Object} The JSON object.
+   */
+  toJSON() {
+    return this.constructor.toJSON(this);
+  }
+}
+function getTrackTypeForValueTypeName(typeName) {
+  switch (typeName.toLowerCase()) {
+    case "scalar":
+    case "double":
+    case "float":
+    case "number":
+    case "integer":
+      return NumberKeyframeTrack;
+    case "vector":
+    case "vector2":
+    case "vector3":
+    case "vector4":
+      return VectorKeyframeTrack;
+    case "color":
+      return ColorKeyframeTrack;
+    case "quaternion":
+      return QuaternionKeyframeTrack;
+    case "bool":
+    case "boolean":
+      return BooleanKeyframeTrack;
+    case "string":
+      return StringKeyframeTrack;
+  }
+  throw new Error("THREE.KeyframeTrack: Unsupported typeName: " + typeName);
+}
+function parseKeyframeTrack(json) {
+  if (json.type === void 0) {
+    throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");
+  }
+  const trackType = getTrackTypeForValueTypeName(json.type);
+  if (json.times === void 0) {
+    const times = [], values = [];
+    flattenJSON(json.keys, times, values, "value");
+    json.times = times;
+    json.values = values;
+  }
+  if (trackType.parse !== void 0) {
+    return trackType.parse(json);
+  } else {
+    return new trackType(json.name, json.times, json.values, json.interpolation);
+  }
+}
 class Light extends Object3D {
   /**
    * Constructs a new light.
@@ -30421,7 +31548,9 @@ class Event {
     return new Connection(callback, this);
   }
   Fire(...args) {
-    for (const callback of this._callbacks) {
+    for (let i = this._callbacks.length - 1; i >= 0; i--) {
+      const callback = this._callbacks[i];
+      if (!callback) return;
       callback(...args);
     }
   }
@@ -30432,7 +31561,9 @@ class Event {
     }
   }
   Clear() {
-    for (const callback of this._callbacks) {
+    for (let i = this._callbacks.length - 1; i >= 0; i--) {
+      const callback = this._callbacks[i];
+      if (!callback) return;
       this.Disconnect(callback);
     }
     this._callbacks = [];
@@ -30506,6 +31637,9 @@ class Instance {
   get name() {
     return this.Prop("Name");
   }
+  get Parent() {
+    return this.parent;
+  }
   createWrapper() {
     const wrapper = GetWrapperForInstance(this);
     if (wrapper && !this._hasWrappered) {
@@ -33733,7 +34867,7 @@ class Outfit {
         staticFacialAnimation = true;
       }
       let meta = void 0;
-      if (assetOrder !== void 0 || assetPos || assetRot || assetScale || assetHeadShape !== void 0) {
+      if (assetOrder !== void 0 || assetPos || assetRot || assetScale || assetHeadShape !== void 0 || staticFacialAnimation !== void 0) {
         meta = new AssetMeta();
         meta.order = assetOrder;
         meta.position = assetPos;
@@ -36361,11 +37495,15 @@ const API = {
         if (response instanceof ArrayBuffer) {
           const buffer2 = response;
           const mesh = new FileMesh();
-          await mesh.fromBuffer(buffer2);
-          if (FLAGS.ENABLE_API_CACHE && FLAGS.ENABLE_API_MESH_CACHE) {
-            CACHE.Mesh.set(cacheStr, mesh.clone());
+          try {
+            await mesh.fromBuffer(buffer2);
+            if (FLAGS.ENABLE_API_CACHE && FLAGS.ENABLE_API_MESH_CACHE) {
+              CACHE.Mesh.set(cacheStr, mesh.clone());
+            }
+            return mesh;
+          } catch {
+            return new Response();
           }
-          return mesh;
         } else {
           return response;
         }
@@ -42738,6 +43876,7 @@ class ModelLayersDesc {
   targetDeformers;
   targetParents;
   layers;
+  destroyConnection;
   //requires compilation
   _targetMeshes;
   uvToHits;
@@ -43017,16 +44156,23 @@ function getModelLayersDesc(model) {
   if (oldLayerDesc && newLayerDesc.isSame(oldLayerDesc)) {
     return oldLayerDesc;
   } else {
+    oldLayerDesc?.destroyConnection?.Disconnect();
     modelLayers.set(model, newLayerDesc);
+    newLayerDesc.destroyConnection = model.Destroying.Connect(() => {
+      modelLayers.delete(model);
+      newLayerDesc.destroyConnection?.Disconnect();
+      newLayerDesc.destroyConnection = void 0;
+    });
     return newLayerDesc;
   }
 }
 const modelHSRDescs = /* @__PURE__ */ new Map();
-const CACHE_uvToHits = /* @__PURE__ */ new Map();
+const CACHE_uvToHits = new Cache();
 class HSRDesc {
   layers;
   layerTransparent;
   uvsToHits;
+  destroyConnection;
   isSame(other) {
     if (!this.layers && other.layers || this.layers && !other.layers) {
       return false;
@@ -43212,7 +44358,13 @@ function getModelHSRDesc(model) {
   if (oldLayerDesc && newHSRDesc.isSame(oldLayerDesc)) {
     return oldLayerDesc;
   } else {
+    oldLayerDesc?.destroyConnection?.Disconnect();
     modelHSRDescs.set(model, newHSRDesc);
+    newHSRDesc.destroyConnection = model.Destroying.Connect(() => {
+      modelHSRDescs.delete(model);
+      newHSRDesc.destroyConnection?.Disconnect();
+      newHSRDesc.destroyConnection = void 0;
+    });
     return newHSRDesc;
   }
 }
@@ -43266,7 +44418,7 @@ function buildWedge(x, y, z) {
   mesh.coreMesh.increaseFaces(2 * 5);
   let totalVerts = 0;
   let totalFaces = 0;
-  totalVerts = addQuad(mesh, totalVerts, totalFaces, [-x, -y, -z], [x, -y, -z], [x, y, z], [-x, y, z], [0, 1, 0], void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
+  totalVerts = addQuad(mesh, totalVerts, totalFaces, [-x, -y, -z], [x, -y, -z], [x, y, z], [-x, y, z], normalize([0, 1, -1]), void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
   totalFaces += 2;
   totalVerts = addQuad(mesh, totalVerts, totalFaces, [-x, -y, z], [x, -y, z], [x, -y, -z], [-x, -y, -z], [0, -1, 0], void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
   totalFaces += 2;
@@ -43277,7 +44429,7 @@ function buildWedge(x, y, z) {
   addQuad(mesh, totalVerts, totalFaces, [x, y, z], [x, -y, -z], [x, -y, -z], [x, -y, z], [1, 0, 0], void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
   return mesh;
 }
-const HSR_CACHE = /* @__PURE__ */ new Map();
+const HSR_CACHE = new Cache();
 function doHSR(totalUvToHits, targetCage, mesh, moveVerts = true, cacheStr) {
   let closestVertIndexArr = void 0;
   if (cacheStr) {
@@ -43785,7 +44937,7 @@ class MeshDesc {
     }
     threeMesh.castShadow = true;
     threeMesh.geometry = geometry;
-    threeMesh.name = this.instance?.PropOrDefault("Name", "Mesh");
+    threeMesh.name = this.instance?.PropOrDefault("Name", "Mesh") + "_" + this.instance?.id;
     threeMesh.scale.set(mesh.size[0], mesh.size[1], mesh.size[2]);
     this.compilationTimestamp = Date.now() / 1e3;
     return threeMesh;
@@ -43818,6 +44970,11 @@ class MeshDesc {
   fromPart(child) {
     this.canHaveSkinning = false;
     if (child.className === "WedgePart") this.shape = "wedge";
+    switch (child.PropOrDefault("Shape", PartType.Block)) {
+      case PartType.Wedge:
+        this.shape = "wedge";
+        break;
+    }
     const specialMesh = child.FindFirstChildOfClass("SpecialMesh");
     if (specialMesh) {
       switch (specialMesh.Property("MeshType")) {
@@ -45324,10 +46481,13 @@ const __vite_glob_0_11 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
 function diffCFrame(parent, child) {
   return parent.inverse().multiply(child);
 }
+function getBoneName(bone) {
+  return bone.userData.name || bone.name.split("_").pop();
+}
 function boneIsChildOf(bone, parentName) {
   let nextParent = bone.parent;
   while (nextParent) {
-    if (nextParent.name === parentName) {
+    if (getBoneName(nextParent) === parentName) {
       return true;
     }
     nextParent = nextParent.parent;
@@ -45355,13 +46515,15 @@ class SkeletonDesc {
     const boneArr = [];
     for (let i = 0; i < skinning.bones.length; i++) {
       const threeBone = new Bone();
-      threeBone.name = skinning.bones[i].name || "";
-      if (threeBone.name === "HumanoidRootNode") {
-        threeBone.name = "HumanoidRootPart";
+      let boneName = skinning.bones[i].name || "";
+      if (boneName === "HumanoidRootNode") {
+        boneName = "HumanoidRootPart";
       }
-      if (threeBone.name === "root") {
-        threeBone.name = "Root";
+      if (boneName === "root") {
+        boneName = "Root";
       }
+      threeBone.name = "Skeleton_" + this.meshDesc.instance?.id + "_" + boneName;
+      threeBone.userData.name = boneName;
       boneArr.push(threeBone);
     }
     this.bones = boneArr;
@@ -45396,9 +46558,10 @@ class SkeletonDesc {
       throw new Error("FileMesh has no root bone");
     } else {
       log(false, rootBone);
-      if (rootBone && rootBone.name !== "Root") {
+      if (rootBone && getBoneName(rootBone) !== "Root") {
         const trueRootBone = new Bone();
-        trueRootBone.name = "Root";
+        trueRootBone.name = "Skeleton_" + this.meshDesc.instance?.id + "_Root";
+        trueRootBone.userData.name = "Root";
         trueRootBone.position.set(0, 0, 0);
         trueRootBone.rotation.set(0, 0, 0, "YXZ");
         this.boneSourceParts.unshift(void 0);
@@ -45426,7 +46589,7 @@ class SkeletonDesc {
   }
   getBoneWithName(name) {
     for (const bone of this.bones) {
-      if (bone.name === name) {
+      if (getBoneName(bone) === name) {
         return bone;
       }
     }
@@ -45475,13 +46638,13 @@ class SkeletonDesc {
     return sourceNode;
   }
   getBoneWorldCFrame(bone, assembly, selfInstance, includeTransform) {
-    const node = assembly.getNode(bone.name);
+    const node = assembly.getNode(getBoneName(bone));
     const selfNode = selfInstance.w.GetAssemblyNode();
     const sourceNode = this.getSourceNode(selfNode, bone, assembly);
-    if (bone.name === "Root") {
+    if (getBoneName(bone) === "Root") {
       return assembly.traverseCFrame(selfNode, includeTransform, true);
     } else if (node) {
-      if (this.meshDesc.wasDeformed && !this.meshDesc.wasAutoSkinned && bone.name === "Head") {
+      if (this.meshDesc.wasDeformed && !this.meshDesc.wasAutoSkinned && getBoneName(bone) === "Head") {
         const ogCF = assembly.traverseCFrame(node, includeTransform, true);
         const connectorOffset = node.getConnectorOffset(includeTransform).inverse();
         connectorOffset.Orientation = [0, 0, 0];
@@ -45498,7 +46661,7 @@ class SkeletonDesc {
     return this.meshDesc.fileMesh?.facs?.faceBoneNames.includes(boneName);
   }
   addFACS(restCF, bone, assembly) {
-    const isFACS = this.isFACS(bone.name);
+    const isFACS = this.isFACS(getBoneName(bone));
     if (!isFACS) return restCF;
     const facsMesh = this.meshDesc.fileMesh;
     const facs = this.meshDesc.fileMesh?.facs;
@@ -45513,7 +46676,7 @@ class SkeletonDesc {
       new FaceControlsWrapper(faceControls);
       for (let j = 0; j < facs.faceBoneNames.length; j++) {
         const boneName = facs.faceBoneNames[j];
-        if (boneName === bone.name) {
+        if (boneName === getBoneName(bone)) {
           let totalPosition = new Vector32();
           let totalRotation = new Vector32();
           for (let i = 0; i < facs.faceControlNames.length; i++) {
@@ -45576,7 +46739,7 @@ class SkeletonDesc {
       let parentBone = bone.parent;
       if (!(parentBone instanceof Bone)) parentBone = null;
       if (bone && parentBone) {
-        if ((boneIsChildOf(bone, "DynamicHead") || bone.name === "DynamicHead") && this.meshDesc.wasDeformed && !this.meshDesc.wasAutoSkinned) {
+        if ((boneIsChildOf(bone, "DynamicHead") || getBoneName(bone) === "DynamicHead") && this.meshDesc.wasDeformed && !this.meshDesc.wasAutoSkinned) {
           const parentBoneWorldCFrame = this.getOriginalWorldCFrameNoChange(parentBone);
           const boneWorldCFrameNoChange = this.getOriginalWorldCFrameNoChange(bone);
           let diffCF = diffCFrame(parentBoneWorldCFrame, boneWorldCFrameNoChange);
@@ -49136,307 +50299,6 @@ const __vite_glob_0_20 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   __proto__: null,
   PartWrapper
 }, Symbol.toStringTag, { value: "Module" }));
-class SoundWrapperData {
-  audioContext;
-  gainNode;
-  buffer;
-  playingSource;
-}
-class SoundWrapper extends InstanceWrapper {
-  static className = "Sound";
-  static requiredProperties = ["Name", "Looped", "Playing", "Volume", "_data"];
-  setup() {
-    if (!this.instance.HasProperty("Name")) this.instance.addProperty(new Property("Name", DataType.String), this.instance.className);
-    if (!this.instance.HasProperty("Looped")) this.instance.addProperty(new Property("Looped", DataType.Bool), false);
-    if (!this.instance.HasProperty("Playing")) this.instance.addProperty(new Property("Playing", DataType.Bool), false);
-    if (!this.instance.HasProperty("Volume")) this.instance.addProperty(new Property("Volume", DataType.Float32), false);
-    if (!this.instance.HasProperty("_data")) this.instance.addProperty(new Property("_data", DataType.NonSerializable), new SoundWrapperData());
-  }
-  get data() {
-    return this.instance.Prop("_data");
-  }
-  created() {
-    if (this.instance.Prop("Playing")) {
-      this.Play();
-    }
-    this.instance.Destroying.Connect(() => {
-      if (this.data.playingSource) {
-        this.Stop();
-      }
-      this.data.audioContext = void 0;
-      this.data.gainNode = void 0;
-      this.data.buffer = void 0;
-    });
-  }
-  _updateVolume() {
-    if (this.data.gainNode) {
-      if (this.instance.HasProperty("Volume")) {
-        const volume = this.instance.Prop("Volume");
-        this.data.gainNode.gain.value = volume;
-      }
-    }
-  }
-  setPlaying(value) {
-    this.instance.setProperty("Playing", value);
-  }
-  playSource() {
-    if (!this.data.audioContext || !this.data.gainNode || !this.data.buffer) return;
-    this.data.playingSource = this.data.audioContext.createBufferSource();
-    this.data.playingSource.buffer = this.data.buffer;
-    this.data.playingSource.connect(this.data.gainNode);
-    this.data.gainNode.connect(this.data.audioContext.destination);
-    this._updateVolume();
-    this.data.playingSource.start(0);
-    this.data.playingSource.onended = (() => {
-      if (this.instance.Prop("Looped")) {
-        this.Play();
-      } else {
-        this.Stop();
-      }
-    });
-  }
-  Play() {
-    if (!FLAGS.AUDIO_ENABLED) return;
-    this.Stop();
-    this.setPlaying(true);
-    if (!this.data.audioContext) {
-      this.data.audioContext = new AudioContext();
-    }
-    if (!this.data.gainNode) {
-      this.data.gainNode = this.data.audioContext.createGain();
-    }
-    if (!this.data.buffer) {
-      let audioUrl = void 0;
-      if (this.instance.HasProperty("SoundId")) {
-        audioUrl = this.instance.Prop("SoundId");
-      } else if (this.instance.HasProperty("AudioContent")) {
-        audioUrl = this.instance.Prop("AudioContent").uri;
-      }
-      if (audioUrl && audioUrl.length > 0) {
-        API.Asset.GetAssetBuffer(audioUrl).then((responseBuffer) => {
-          if (responseBuffer instanceof Response || !this.data.audioContext) return;
-          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();
-          });
-        });
-      }
-    } else if (this.data.buffer) {
-      this.playSource();
-    }
-  }
-  Stop() {
-    this.setPlaying(false);
-    if (this.data.playingSource) {
-      this.data.playingSource.stop();
-      this.data.playingSource = void 0;
-    }
-  }
-}
-const __vite_glob_0_22 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  SoundWrapper
-}, Symbol.toStringTag, { value: "Module" }));
-class ScriptWrapperData {
-  shouldStop = false;
-}
-class ScriptWrapper extends InstanceWrapper {
-  static className = "Script";
-  static requiredProperties = ["Name", "_data"];
-  setup() {
-    if (!this.instance.HasProperty("Name")) this.instance.addProperty(new Property("Name", DataType.String), this.instance.className);
-    if (!this.instance.HasProperty("_data")) this.instance.addProperty(new Property("_data", DataType.NonSerializable), new ScriptWrapperData());
-  }
-  get data() {
-    return this.instance.Prop("_data");
-  }
-  created() {
-    this.Run();
-  }
-  Run() {
-    switch (this.instance.Prop("Name")) {
-      case "ChickenSounds":
-      case "HarmonicaSounds":
-      case "SoundPlayer":
-        this.SoundPlayer(this.instance);
-        break;
-    }
-  }
-  //Scripts
-  async SoundPlayer(script) {
-    let Handle = void 0;
-    if (script.parent && script.parent.Prop("Name") === "Handle") {
-      Handle = script.parent;
-    } else if (script.parent && script.parent.FindFirstChild("Handle")) {
-      Handle = script.parent.FindFirstChild("Handle");
-    }
-    if (!Handle) return;
-    const Hat = Handle.parent;
-    if (!Hat) return;
-    const Sounds = [];
-    for (const child of Handle.GetDescendants()) {
-      if (child.className === "Sound") {
-        Sounds.push(child);
-      }
-    }
-    function IsBeingWorn() {
-      return Hat?.parent?.FindFirstChild("Humanoid");
-    }
-    let maxTime = 20;
-    if (script.Prop("Name") === "SoundPlayer") {
-      maxTime = 15;
-    }
-    while (true) {
-      await Wait(mathRandom(5, maxTime));
-      if (this.instance.destroyed || this.data.shouldStop) return;
-      if (IsBeingWorn()) {
-        const index = mathRandom(0, Sounds.length - 1);
-        const Sound = Sounds[index];
-        const soundWrapper = new SoundWrapper(Sound);
-        soundWrapper.Play();
-      }
-    }
-  }
-}
-const __vite_glob_0_21 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  ScriptWrapper
-}, Symbol.toStringTag, { value: "Module" }));
-class ToolWrapper extends InstanceWrapper {
-  static className = "Tool";
-  static requiredProperties = [
-    "Name",
-    "Grip"
-  ];
-  setup() {
-    if (!this.instance.HasProperty("Name")) this.instance.addProperty(new Property("Name", DataType.String), this.instance.className);
-    if (!this.instance.HasProperty("Grip")) this.instance.addProperty(new Property("Grip", DataType.CFrame), new CFrame());
-  }
-  created() {
-    this.instance.AncestryChanged.Connect(() => {
-      this.createWeld();
-    });
-  }
-  //doing this is actually inaccurate because tools dont create welds, but its easier
-  createWeld() {
-    const handle = this.instance.FindFirstChild("Handle");
-    const rig = this.instance.parent;
-    const grip = this.instance.PropOrDefault("Grip", new CFrame()).clone();
-    if (handle) {
-      const oldToolWeld = handle.FindFirstChild("ToolWeld_GripRoAvatar");
-      if (oldToolWeld) {
-        oldToolWeld.Destroy();
-      }
-    }
-    const humanoid = rig?.FindFirstChildOfClass("Humanoid");
-    if (handle && rig && rig.className === "Model" && humanoid) {
-      const rightHand = rig.FindFirstChild("RightHand") || rig.FindFirstChild("Right Arm");
-      if (rightHand) {
-        for (const child of rightHand.GetDescendants()) {
-          if (child.Prop("Name") === "RightGripAttachment") {
-            const rightGripAttCF = child.PropOrDefault("CFrame", new CFrame()).clone();
-            if (humanoid.Prop("RigType") === HumanoidRigType.R6) {
-              rightGripAttCF.Orientation[0] -= 90;
-            }
-            const weld = new Instance("Weld");
-            weld.addProperty(new Property("Name", DataType.String), "ToolWeld_GripRoAvatar");
-            weld.addProperty(new Property("Archivable", DataType.Bool), true);
-            weld.addProperty(new Property("C0", DataType.CFrame), rightGripAttCF);
-            weld.addProperty(new Property("C1", DataType.CFrame), grip);
-            weld.addProperty(new Property("Part0", DataType.Referent), child.parent);
-            weld.addProperty(new Property("Part1", DataType.Referent), handle);
-            weld.addProperty(new Property("Active", DataType.Bool), true);
-            weld.addProperty(new Property("Enabled", DataType.Bool), false);
-            weld.setParent(handle);
-            weld.setProperty("Enabled", true);
-          }
-        }
-      }
-    }
-  }
-}
-const __vite_glob_0_23 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  ToolWrapper
-}, Symbol.toStringTag, { value: "Module" }));
-class WedgePartWrapper extends BasePartWrapper {
-  static className = "WedgePart";
-}
-const __vite_glob_0_24 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  WedgePartWrapper
-}, Symbol.toStringTag, { value: "Module" }));
-class WeldWrapper extends JointInstanceWrapper {
-  static className = "Weld";
-}
-const __vite_glob_0_25 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  WeldWrapper
-}, Symbol.toStringTag, { value: "Module" }));
-const modules$1 = /* @__PURE__ */ Object.assign({ "./instance/Accessory.ts": __vite_glob_0_0$1, "./instance/AccessoryDescription.ts": __vite_glob_0_1$1, "./instance/AnimationConstraint.ts": __vite_glob_0_2$1, "./instance/Animator.ts": __vite_glob_0_3, "./instance/Attachment.ts": __vite_glob_0_4, "./instance/BasePart.ts": __vite_glob_0_5, "./instance/BodyColors.ts": __vite_glob_0_6, "./instance/BodyPartDescription.ts": __vite_glob_0_7, "./instance/Bone.ts": __vite_glob_0_8, "./instance/Constraint.ts": __vite_glob_0_9, "./instance/Decal.ts": __vite_glob_0_10, "./instance/FaceControls.ts": __vite_glob_0_11, "./instance/HumanoidDescription.ts": __vite_glob_0_12, "./instance/InstanceWrapper.ts": __vite_glob_0_13, "./instance/JointInstance.ts": __vite_glob_0_14, "./instance/MakeupDescription.ts": __vite_glob_0_15, "./instance/ManualWeld.ts": __vite_glob_0_16, "./instance/MeshPart.ts": __vite_glob_0_17, "./instance/Model.ts": __vite_glob_0_18, "./instance/Motor6D.ts": __vite_glob_0_19, "./instance/Part.ts": __vite_glob_0_20, "./instance/Script.ts": __vite_glob_0_21, "./instance/Sound.ts": __vite_glob_0_22, "./instance/Tool.ts": __vite_glob_0_23, "./instance/WedgePart.ts": __vite_glob_0_24, "./instance/Weld.ts": __vite_glob_0_25 });
-function RegisterWrappers() {
-  for (const module of Object.values(modules$1)) {
-    for (const exprt of Object.values(module)) {
-      let prototype = Object.getPrototypeOf(exprt);
-      while (prototype) {
-        if (prototype === InstanceWrapper) {
-          exprt.register();
-          break;
-        }
-        prototype = Object.getPrototypeOf(prototype);
-      }
-    }
-  }
-}
-const attachmentGeometry = new SphereGeometry(0.125, 16, 8);
-class AttachmentDesc extends RenderDesc {
-  static classTypes = ["Attachment"];
-  visible = false;
-  cframe = new CFrame();
-  isSame(other) {
-    return this.visible === other.visible && this.cframe.isSame(other.cframe);
-  }
-  needsRegeneration(other) {
-    return this.visible !== other.visible;
-  }
-  virtualFromRenderDesc(other) {
-    this.cframe = other.cframe.clone();
-  }
-  fromInstance(child) {
-    const attachmentW = new AttachmentWrapper(child);
-    this.cframe = attachmentW.getWorldCFrame();
-    this.visible = child.PropOrDefault("Visible", this.visible) || FLAGS.ALWAYS_SHOW_ATTACHMENTS;
-  }
-  async compileResults() {
-    this.results = [];
-    if (this.visible) {
-      const mesh = new Mesh(attachmentGeometry, new MeshLambertMaterial({ color: 65280 }));
-      mesh.name = this.instance ? this.instance.PropOrDefault("Name", "Unknown") + "_Att" : "Unknown_Att";
-      this.results.push(mesh);
-    }
-    this.updateResults();
-    return this.results;
-  }
-  updateResults() {
-    if (!this.results) return;
-    for (const attachment of this.results) {
-      const resultCF = this.cframe;
-      setTHREEObjectCF(attachment, resultCF);
-    }
-  }
-  dispose(_renderer, scene) {
-    if (!this.results) return;
-    for (const result of this.results) {
-      scene.remove(result);
-    }
-  }
-}
-const __vite_glob_0_0 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  AttachmentDesc
-}, Symbol.toStringTag, { value: "Module" }));
 const particle_vertexShader = (
   /*glsl*/
   `
@@ -49894,8 +50756,8 @@ class EmitterDesc extends DisposableDesc {
     }
     return this.result;
   }
-  emit(groupDesc) {
-    if (this.particles.length >= this.maxCount || groupDesc.enabled === false) {
+  emit(groupDesc, force = false) {
+    if (this.particles.length >= this.maxCount || groupDesc.enabled === false && !force) {
       return;
     }
     const speed = randomBetween(this.speed.Min, this.speed.Max);
@@ -50093,6 +50955,7 @@ class EmitterGroupDesc extends RenderDesc {
     this.lowerBound = other.lowerBound;
     this.higherBound = other.higherBound;
     this.emitterDir = other.emitterDir;
+    this.enabled = other.enabled;
     for (let i = 0; i < this.emitterDescs.length; i++) {
       this.emitterDescs[i].fromEmitterDesc(other.emitterDescs[i]);
     }
@@ -50334,6 +51197,521 @@ const __vite_glob_0_1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.def
   __proto__: null,
   EmitterGroupDesc
 }, Symbol.toStringTag, { value: "Module" }));
+class ParticleEmitterWrapper extends InstanceWrapper {
+  static className = "ParticleEmitter";
+  static requiredProperties = [
+    "Name"
+  ];
+  setup() {
+    if (!this.instance.HasProperty("Name")) this.instance.addProperty(new Property("Name", DataType.String), this.instance.className);
+  }
+  Emit(count = 16) {
+    const renderDescs = RBXRenderer.getRenderDescs(this.instance);
+    for (const renderDesc of renderDescs) {
+      if (renderDesc instanceof EmitterGroupDesc) {
+        for (const emitterDesc of renderDesc.emitterDescs) {
+          for (let i = 0; i < count; i++) {
+            emitterDesc.emit(renderDesc, true);
+          }
+        }
+      }
+    }
+  }
+}
+const __vite_glob_0_21 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ParticleEmitterWrapper
+}, Symbol.toStringTag, { value: "Module" }));
+class SoundWrapperData {
+  audioContext;
+  gainNode;
+  buffer;
+  playingSource;
+}
+class SoundWrapper extends InstanceWrapper {
+  static className = "Sound";
+  static requiredProperties = ["Name", "Looped", "Playing", "Volume", "_data"];
+  setup() {
+    if (!this.instance.HasProperty("Name")) this.instance.addProperty(new Property("Name", DataType.String), this.instance.className);
+    if (!this.instance.HasProperty("Looped")) this.instance.addProperty(new Property("Looped", DataType.Bool), false);
+    if (!this.instance.HasProperty("Playing")) this.instance.addProperty(new Property("Playing", DataType.Bool), false);
+    if (!this.instance.HasProperty("Volume")) this.instance.addProperty(new Property("Volume", DataType.Float32), false);
+    if (!this.instance.HasProperty("_data")) this.instance.addProperty(new Property("_data", DataType.NonSerializable), new SoundWrapperData());
+  }
+  get data() {
+    return this.instance.Prop("_data");
+  }
+  created() {
+    if (this.instance.Prop("Playing")) {
+      this.Play();
+    }
+    this.instance.Destroying.Connect(() => {
+      if (this.data.playingSource) {
+        this.Stop();
+      }
+      this.data.audioContext = void 0;
+      this.data.gainNode = void 0;
+      this.data.buffer = void 0;
+    });
+  }
+  _updateVolume() {
+    if (this.data.gainNode) {
+      if (this.instance.HasProperty("Volume")) {
+        const volume = this.instance.Prop("Volume");
+        this.data.gainNode.gain.value = volume;
+      }
+    }
+  }
+  setPlaying(value) {
+    this.instance.setProperty("Playing", value);
+  }
+  playSource() {
+    if (!this.data.audioContext || !this.data.gainNode || !this.data.buffer) return;
+    this.data.playingSource = this.data.audioContext.createBufferSource();
+    this.data.playingSource.buffer = this.data.buffer;
+    this.data.playingSource.connect(this.data.gainNode);
+    this.data.gainNode.connect(this.data.audioContext.destination);
+    this._updateVolume();
+    this.data.playingSource.start(0);
+    this.data.playingSource.onended = (() => {
+      if (this.instance.Prop("Looped")) {
+        this.Play();
+      } else {
+        this.Stop();
+      }
+    });
+  }
+  Play() {
+    if (!FLAGS.AUDIO_ENABLED) return;
+    this.Stop();
+    this.setPlaying(true);
+    if (!this.data.audioContext) {
+      this.data.audioContext = new AudioContext();
+    }
+    if (!this.data.gainNode) {
+      this.data.gainNode = this.data.audioContext.createGain();
+    }
+    if (!this.data.buffer) {
+      let audioUrl = void 0;
+      if (this.instance.HasProperty("SoundId")) {
+        audioUrl = this.instance.Prop("SoundId");
+      } else if (this.instance.HasProperty("AudioContent")) {
+        audioUrl = this.instance.Prop("AudioContent").uri;
+      }
+      if (audioUrl && audioUrl.length > 0) {
+        API.Asset.GetAssetBuffer(audioUrl).then((responseBuffer) => {
+          if (responseBuffer instanceof Response || !this.data.audioContext) return;
+          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();
+          });
+        });
+      }
+    } else if (this.data.buffer) {
+      this.playSource();
+    }
+  }
+  Stop() {
+    this.setPlaying(false);
+    if (this.data.playingSource) {
+      this.data.playingSource.stop();
+      this.data.playingSource = void 0;
+    }
+  }
+}
+const __vite_glob_0_23 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  SoundWrapper
+}, Symbol.toStringTag, { value: "Module" }));
+class ScriptWrapperData {
+  shouldStop = false;
+}
+class ScriptWrapper extends InstanceWrapper {
+  static className = "Script";
+  static requiredProperties = ["Name", "_data"];
+  setup() {
+    if (!this.instance.HasProperty("Name")) this.instance.addProperty(new Property("Name", DataType.String), this.instance.className);
+    if (!this.instance.HasProperty("_data")) this.instance.addProperty(new Property("_data", DataType.NonSerializable), new ScriptWrapperData());
+  }
+  get data() {
+    return this.instance.Prop("_data");
+  }
+  created() {
+    this.Run();
+  }
+  Run() {
+    switch (this.instance.Prop("Name")) {
+      case "ChickenSounds":
+      case "HarmonicaSounds":
+      case "SoundPlayer":
+        this.SoundPlayer(this.instance);
+        break;
+      case "HatScript2.0":
+        this.HatScript20(this.instance);
+        break;
+    }
+  }
+  //Scripts
+  async SoundPlayer(script) {
+    let Handle = void 0;
+    if (script.parent && script.parent.Prop("Name") === "Handle") {
+      Handle = script.parent;
+    } else if (script.parent && script.parent.FindFirstChild("Handle")) {
+      Handle = script.parent.FindFirstChild("Handle");
+    }
+    if (!Handle) return;
+    const Hat = Handle.parent;
+    if (!Hat) return;
+    const Sounds = [];
+    for (const child of Handle.GetDescendants()) {
+      if (child.className === "Sound") {
+        Sounds.push(child);
+      }
+    }
+    function IsBeingWorn() {
+      return Hat?.parent?.FindFirstChild("Humanoid");
+    }
+    let maxTime = 20;
+    if (script.Prop("Name") === "SoundPlayer") {
+      maxTime = 15;
+    }
+    while (true) {
+      await Wait(mathRandom(5, maxTime));
+      if (this.instance.destroyed || this.data.shouldStop) return;
+      if (IsBeingWorn()) {
+        const index = mathRandom(0, Sounds.length - 1);
+        const Sound = Sounds[index];
+        const soundWrapper = new SoundWrapper(Sound);
+        soundWrapper.Play();
+      }
+    }
+  }
+  async HatScript20(script) {
+    const now = /* @__PURE__ */ new Date();
+    const month = now.getMonth();
+    const day = now.getDay();
+    const data = this.data;
+    let hw;
+    let tg;
+    let xm;
+    let bd;
+    let pt;
+    let vt;
+    let af;
+    if (month == 10 && day > 21) {
+      hw = true;
+    } else if (month == 11 && day > 19) {
+      tg = true;
+    } else if (month == 12 && day > 17 && day < 28) {
+      xm = true;
+    } else if (month == 9 && day == 1) {
+      bd = true;
+    } else if (month == 3 && day > 11 && day < 20) {
+      pt = true;
+    } else if (month == 2 && day > 8 && day < 17) {
+      vt = true;
+    } else if (month == 4 && day == 1) {
+      af = true;
+    }
+    let emitter = script.parent?.Child("ParticleEmitter");
+    const burst = script.parent?.Child("Burst");
+    async function snowBlower() {
+      const snow1 = script.parent?.Child("Snowflake1");
+      const snow2 = script.parent?.Child("Snowflake2");
+      while (true) {
+        await Wait(Math.random() * 5);
+        if (script.destroyed || data.shouldStop) return;
+        snow1?.setProperty("Enabled", false);
+        snow2?.setProperty("Enabled", true);
+        await Wait(Math.random() * 5);
+        if (script.destroyed || data.shouldStop) return;
+        snow1?.setProperty("Enabled", true);
+        snow2?.setProperty("Enabled", false);
+        if (Math.random() > 0.97) {
+          snow1?.setProperty("Enabled", false);
+          await Wait(4);
+          if (script.destroyed || data.shouldStop) return;
+          (snow1?.w).Emit(22);
+          await Wait(Math.random());
+          if (script.destroyed || data.shouldStop) return;
+          (snow2?.w).Emit(22);
+          await Wait(2);
+          if (script.destroyed || data.shouldStop) return;
+        }
+      }
+    }
+    async function leafBlower() {
+      const leaf1 = script.parent?.Child("Leaf1");
+      const leaf2 = script.parent?.Child("Leaf2");
+      while (true) {
+        await Wait(Math.random() * 5);
+        if (script.destroyed || data.shouldStop) return;
+        leaf1?.setProperty("Enabled", false);
+        leaf2?.setProperty("Enabled", true);
+        await Wait(Math.random() * 5);
+        if (script.destroyed || data.shouldStop) return;
+        leaf1?.setProperty("Enabled", true);
+        leaf2?.setProperty("Enabled", false);
+        if (Math.random() > 0.97) {
+          leaf1?.setProperty("Enabled", false);
+          await Wait(4);
+          if (script.destroyed || data.shouldStop) return;
+          (leaf1?.w).Emit(22);
+          await Wait(Math.random());
+          if (script.destroyed || data.shouldStop) return;
+          (leaf2?.w).Emit(22);
+          await Wait(2);
+          if (script.destroyed || data.shouldStop) return;
+        }
+      }
+    }
+    async function cloverBlower() {
+      const leaf1 = script.parent?.Child("Clover1");
+      const leaf2 = script.parent?.Child("Clover2");
+      while (true) {
+        await Wait(Math.random() * 5);
+        if (script.destroyed || data.shouldStop) return;
+        leaf1?.setProperty("Enabled", false);
+        leaf2?.setProperty("Enabled", true);
+        await Wait(Math.random() * 5);
+        if (script.destroyed || data.shouldStop) return;
+        leaf1?.setProperty("Enabled", true);
+        leaf2?.setProperty("Enabled", false);
+        if (Math.random() > 0.97) {
+          leaf1?.setProperty("Enabled", false);
+          await Wait(4);
+          if (script.destroyed || data.shouldStop) return;
+          (leaf1?.w).Emit(22);
+          await Wait(Math.random());
+          if (script.destroyed || data.shouldStop) return;
+          (leaf2?.w).Emit(22);
+          await Wait(2);
+          if (script.destroyed || data.shouldStop) return;
+        }
+      }
+    }
+    if (hw) {
+      emitter?.setProperty("Enabled", false);
+      emitter = script.parent?.Child("Hallow");
+      if (script.parent?.parent?.IsA("MeshPart")) {
+        script.parent?.parent?.setProperty("TextureID", "rbxassetid://6991166143");
+      } else {
+        script.parent?.parent?.Child("Mesh")?.setProperty("TextureId", "rbxassetid://6991166143");
+      }
+    } else if (tg) {
+      if (script.parent?.parent?.IsA("MeshPart")) {
+        script.parent?.parent?.setProperty("TextureID", "rbxassetid://6991393806");
+      } else {
+        script.parent?.parent?.Child("Mesh")?.setProperty("TextureId", "rbxassetid://6991393806");
+      }
+      leafBlower();
+    } else if (xm) {
+      emitter?.setProperty("Enabled", false);
+      emitter = script.parent?.Child("Snowflake3");
+      snowBlower();
+    } else if (bd) {
+      emitter?.setProperty("Enabled", false);
+      emitter = script.parent?.Child("Confetti");
+      if (script.parent?.parent?.IsA("MeshPart")) {
+        script.parent?.parent?.setProperty("TextureID", "rbxassetid://2399316028");
+      } else {
+        script.parent?.parent?.Child("Mesh")?.setProperty("TextureId", "rbxassetid://2399316028");
+      }
+    } else if (pt) {
+      if (script.Parent?.Parent?.IsA("MeshPart")) {
+        script.parent?.parent?.setProperty("TextureID", "rbxassetid://2399447918");
+      } else {
+        script.parent?.parent?.Child("Mesh")?.setProperty("TextureId", "rbxassetid://2399447918");
+      }
+      cloverBlower();
+    } else if (vt) {
+      emitter?.setProperty("Enabled", false);
+      emitter = script.Parent?.Child("Heart");
+      if (script.Parent?.Parent?.IsA("MeshPart")) {
+        script.parent?.parent?.setProperty("TextureID", "rbxassetid://2399448372");
+      } else {
+        script.parent?.parent?.Child("Mesh")?.setProperty("TextureId", "rbxassetid://2399448372");
+      }
+    } else if (af) {
+      emitter?.setProperty("Enabled", false);
+      emitter = script.Parent?.Child("Hats");
+      script.Parent?.Child("Smokescreen")?.setProperty("Enabled", true);
+      script.Parent?.Parent?.setProperty("Transparency", 1);
+    }
+    while (true) {
+      await Wait(1.3);
+      if (script.destroyed || data.shouldStop) return;
+      emitter?.setProperty("Enabled", false);
+      await Wait(0.8);
+      if (script.destroyed || data.shouldStop) return;
+      emitter?.setProperty("Enabled", true);
+      const rando = Math.random();
+      if (rando > 0.97) {
+        emitter?.setProperty("Enabled", false);
+        await Wait(4);
+        if (script.destroyed || data.shouldStop) return;
+        burst?.setProperty("Enabled", true);
+        await Wait(2);
+        if (script.destroyed || data.shouldStop) return;
+        burst?.setProperty("Enabled", false);
+        emitter?.setProperty("Enabled", true);
+      } else if (rando > 0.969) {
+        emitter?.setProperty("Enabled", false);
+        await Wait(4);
+        if (script.destroyed || data.shouldStop) return;
+        for (const v of script.Parent?.GetChildren() || []) {
+          if (v.IsA("ParticleEmitter")) {
+            v.w.Emit(mathRandom(6, 10));
+            await Wait(0.5);
+            if (script.destroyed || data.shouldStop) return;
+          }
+        }
+        await Wait(2);
+        if (script.destroyed || data.shouldStop) return;
+        emitter?.setProperty("Enabled", true);
+      }
+    }
+  }
+}
+const __vite_glob_0_22 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ScriptWrapper
+}, Symbol.toStringTag, { value: "Module" }));
+class ToolWrapper extends InstanceWrapper {
+  static className = "Tool";
+  static requiredProperties = [
+    "Name",
+    "Grip"
+  ];
+  setup() {
+    if (!this.instance.HasProperty("Name")) this.instance.addProperty(new Property("Name", DataType.String), this.instance.className);
+    if (!this.instance.HasProperty("Grip")) this.instance.addProperty(new Property("Grip", DataType.CFrame), new CFrame());
+  }
+  created() {
+    this.instance.AncestryChanged.Connect(() => {
+      this.createWeld();
+    });
+  }
+  //doing this is actually inaccurate because tools dont create welds, but its easier
+  createWeld() {
+    const handle = this.instance.FindFirstChild("Handle");
+    const rig = this.instance.parent;
+    const grip = this.instance.PropOrDefault("Grip", new CFrame()).clone();
+    if (handle) {
+      const oldToolWeld = handle.FindFirstChild("ToolWeld_GripRoAvatar");
+      if (oldToolWeld) {
+        oldToolWeld.Destroy();
+      }
+    }
+    const humanoid = rig?.FindFirstChildOfClass("Humanoid");
+    if (handle && rig && rig.className === "Model" && humanoid) {
+      const rightHand = rig.FindFirstChild("RightHand") || rig.FindFirstChild("Right Arm");
+      if (rightHand) {
+        for (const child of rightHand.GetDescendants()) {
+          if (child.Prop("Name") === "RightGripAttachment") {
+            const rightGripAttCF = child.PropOrDefault("CFrame", new CFrame()).clone();
+            if (humanoid.Prop("RigType") === HumanoidRigType.R6) {
+              rightGripAttCF.Orientation[0] -= 90;
+            }
+            const weld = new Instance("Weld");
+            weld.addProperty(new Property("Name", DataType.String), "ToolWeld_GripRoAvatar");
+            weld.addProperty(new Property("Archivable", DataType.Bool), true);
+            weld.addProperty(new Property("C0", DataType.CFrame), rightGripAttCF);
+            weld.addProperty(new Property("C1", DataType.CFrame), grip);
+            weld.addProperty(new Property("Part0", DataType.Referent), child.parent);
+            weld.addProperty(new Property("Part1", DataType.Referent), handle);
+            weld.addProperty(new Property("Active", DataType.Bool), true);
+            weld.addProperty(new Property("Enabled", DataType.Bool), false);
+            weld.setParent(handle);
+            weld.setProperty("Enabled", true);
+          }
+        }
+      }
+    }
+  }
+}
+const __vite_glob_0_24 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ToolWrapper
+}, Symbol.toStringTag, { value: "Module" }));
+class WedgePartWrapper extends BasePartWrapper {
+  static className = "WedgePart";
+}
+const __vite_glob_0_25 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  WedgePartWrapper
+}, Symbol.toStringTag, { value: "Module" }));
+class WeldWrapper extends JointInstanceWrapper {
+  static className = "Weld";
+}
+const __vite_glob_0_26 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  WeldWrapper
+}, Symbol.toStringTag, { value: "Module" }));
+const modules$1 = /* @__PURE__ */ Object.assign({ "./instance/Accessory.ts": __vite_glob_0_0$1, "./instance/AccessoryDescription.ts": __vite_glob_0_1$1, "./instance/AnimationConstraint.ts": __vite_glob_0_2$1, "./instance/Animator.ts": __vite_glob_0_3, "./instance/Attachment.ts": __vite_glob_0_4, "./instance/BasePart.ts": __vite_glob_0_5, "./instance/BodyColors.ts": __vite_glob_0_6, "./instance/BodyPartDescription.ts": __vite_glob_0_7, "./instance/Bone.ts": __vite_glob_0_8, "./instance/Constraint.ts": __vite_glob_0_9, "./instance/Decal.ts": __vite_glob_0_10, "./instance/FaceControls.ts": __vite_glob_0_11, "./instance/HumanoidDescription.ts": __vite_glob_0_12, "./instance/InstanceWrapper.ts": __vite_glob_0_13, "./instance/JointInstance.ts": __vite_glob_0_14, "./instance/MakeupDescription.ts": __vite_glob_0_15, "./instance/ManualWeld.ts": __vite_glob_0_16, "./instance/MeshPart.ts": __vite_glob_0_17, "./instance/Model.ts": __vite_glob_0_18, "./instance/Motor6D.ts": __vite_glob_0_19, "./instance/Part.ts": __vite_glob_0_20, "./instance/ParticleEmitter.ts": __vite_glob_0_21, "./instance/Script.ts": __vite_glob_0_22, "./instance/Sound.ts": __vite_glob_0_23, "./instance/Tool.ts": __vite_glob_0_24, "./instance/WedgePart.ts": __vite_glob_0_25, "./instance/Weld.ts": __vite_glob_0_26 });
+function RegisterWrappers() {
+  for (const module of Object.values(modules$1)) {
+    for (const exprt of Object.values(module)) {
+      let prototype = Object.getPrototypeOf(exprt);
+      while (prototype) {
+        if (prototype === InstanceWrapper) {
+          exprt.register();
+          break;
+        }
+        prototype = Object.getPrototypeOf(prototype);
+      }
+    }
+  }
+}
+const attachmentGeometry = new SphereGeometry(0.125, 16, 8);
+class AttachmentDesc extends RenderDesc {
+  static classTypes = ["Attachment"];
+  visible = false;
+  cframe = new CFrame();
+  isSame(other) {
+    return this.visible === other.visible && this.cframe.isSame(other.cframe);
+  }
+  needsRegeneration(other) {
+    return this.visible !== other.visible;
+  }
+  virtualFromRenderDesc(other) {
+    this.cframe = other.cframe.clone();
+  }
+  fromInstance(child) {
+    const attachmentW = new AttachmentWrapper(child);
+    this.cframe = attachmentW.getWorldCFrame();
+    this.visible = child.PropOrDefault("Visible", this.visible) || FLAGS.ALWAYS_SHOW_ATTACHMENTS;
+  }
+  async compileResults() {
+    this.results = [];
+    if (this.visible) {
+      const mesh = new Mesh(attachmentGeometry, new MeshLambertMaterial({ color: 65280 }));
+      mesh.name = this.instance ? this.instance.PropOrDefault("Name", "Unknown") + "_Att" : "Unknown_Att";
+      this.results.push(mesh);
+    }
+    this.updateResults();
+    return this.results;
+  }
+  updateResults() {
+    if (!this.results) return;
+    for (const attachment of this.results) {
+      const resultCF = this.cframe;
+      setTHREEObjectCF(attachment, resultCF);
+    }
+  }
+  dispose(_renderer, scene) {
+    if (!this.results) return;
+    for (const result of this.results) {
+      scene.remove(result);
+    }
+  }
+}
+const __vite_glob_0_0 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AttachmentDesc
+}, Symbol.toStringTag, { value: "Module" }));
 function disposeLight(scene, light) {
   if (light.shadow && light.shadow.map) {
     light.shadow.map.dispose();
@@ -50589,7 +51967,125 @@ class RBXRendererScene {
    * @param autoDownload If resulting file should be auto downloaded
    * @returns The GLB (buffer) or GLTF (object)
    */
-  async exportGLTF(name = "scene", autoDownload = true) {
+  async exportGLTF(name = "scene", autoDownload = true, options) {
+    const actualOptions = {
+      includeAnimations: false,
+      binary: false
+    };
+    if (options) Object.assign(actualOptions, options);
+    const clips = [];
+    let animator = void 0;
+    let allInstances = [];
+    let rootInstance = void 0;
+    const allRenderedInstances = Array.from(this.renderDescs.keys());
+    let parent = allRenderedInstances[0].parent;
+    while (parent !== void 0) {
+      if (parent.parent === void 0) {
+        rootInstance = parent;
+        allInstances = [parent, ...parent.GetDescendants()];
+        break;
+      }
+      parent = parent.parent;
+    }
+    for (const instance of allInstances) {
+      if (instance.className === "Animator") {
+        animator = instance;
+        break;
+      }
+    }
+    const GLTF_FPS = 30;
+    if (animator && actualOptions.includeAnimations && rootInstance) {
+      const w = animator.w;
+      for (const animationEntryKey of Object.keys(w.data.animationSet)) {
+        let trackIndex = 0;
+        for (const animationEntry of w.data.animationSet[animationEntryKey]) {
+          const track = w._getTrack(animationEntry.id);
+          if (track) {
+            const objectPositions = /* @__PURE__ */ new Map();
+            const objectRotations = /* @__PURE__ */ new Map();
+            const bonePositions = /* @__PURE__ */ new Map();
+            const boneQuaternions = /* @__PURE__ */ new Map();
+            track.weight = 1;
+            const times = [];
+            for (let i = 0; i < Math.max(1, Math.ceil(track.length * GLTF_FPS)); i++) {
+              w.restPose();
+              track.setTime(i / GLTF_FPS);
+              if (w.data.currentMoodAnimationTrack) w.data.currentMoodAnimationTrack.setTime(0);
+              times.push(i / GLTF_FPS);
+              rootInstance.preRender();
+              RBXRenderer.addInstance(rootInstance, new Authentication(), this);
+              for (const instance of allRenderedInstances) {
+                if (instance.className === "Attachment") continue;
+                let isSkinned = false;
+                const renderDesc = this.renderDescs.get(instance);
+                if (renderDesc && renderDesc instanceof ObjectDesc && renderDesc.skeletonDesc) {
+                  isSkinned = true;
+                  const bones = renderDesc.skeletonDesc.bones;
+                  for (const bone of bones) {
+                    if (!bonePositions.has(bone)) bonePositions.set(bone, []);
+                    if (!boneQuaternions.has(bone)) boneQuaternions.set(bone, []);
+                    bonePositions.get(bone).push(bone.position.toArray());
+                    boneQuaternions.get(bone).push(bone.quaternion.toArray());
+                  }
+                }
+                let partToUse = instance;
+                if (partToUse.className === "Decal" && partToUse.parent) {
+                  partToUse = partToUse.parent;
+                }
+                let cf = partToUse.PropOrDefault("CFrame", new CFrame());
+                if (isSkinned) {
+                  cf = new CFrame();
+                }
+                if (!objectPositions.has(instance)) objectPositions.set(instance, []);
+                if (!objectRotations.has(instance)) objectRotations.set(instance, []);
+                objectPositions.get(instance).push(cf.Position);
+                objectRotations.get(instance).push([rad(cf.Orientation[0]), rad(cf.Orientation[1]), rad(cf.Orientation[2])]);
+              }
+            }
+            const keyframeTracks = [];
+            for (const instance of allRenderedInstances) {
+              if (instance.className === "Attachment") continue;
+              const thisPositions = objectPositions.get(instance);
+              const thisRotations = objectRotations.get(instance);
+              if (thisPositions && thisRotations) {
+                const instanceName = instance.PropOrDefault("Name", "Mesh") + "_" + instance.id;
+                keyframeTracks.push(new VectorKeyframeTrack(instanceName + ".position", times, thisPositions.flat()));
+                const quaternionValues = [];
+                for (const rotationValue of thisRotations) {
+                  const quat = new Quaternion().setFromEuler(new Euler(...rotationValue, "YXZ"));
+                  quaternionValues.push(quat.x, quat.y, quat.z, quat.w);
+                }
+                keyframeTracks.push(new QuaternionKeyframeTrack(instanceName + ".quaternion", times, quaternionValues));
+              }
+              const renderDesc = this.renderDescs.get(instance);
+              if (renderDesc && renderDesc instanceof ObjectDesc && renderDesc.skeletonDesc) {
+                const bones = renderDesc.skeletonDesc.bones;
+                for (const bone of bones) {
+                  const thisBonePositions = bonePositions.get(bone);
+                  const thisBoneQuaternions = boneQuaternions.get(bone);
+                  if (thisBonePositions && thisBoneQuaternions) {
+                    keyframeTracks.push(new VectorKeyframeTrack(bone.name + ".position", times, thisBonePositions.flat()));
+                    keyframeTracks.push(new QuaternionKeyframeTrack(bone.name + ".quaternion", times, thisBoneQuaternions.flat()));
+                  }
+                }
+              }
+            }
+            const clip = new AnimationClip(animationEntryKey + "_" + trackIndex, track.length, keyframeTracks);
+            clips.push(clip);
+            console.log(`Generated clip (${clip.name}) with ${clip.tracks.length} tracks and length of ${track.length}`);
+          }
+          trackIndex += 1;
+        }
+      }
+      w.restPose();
+      rootInstance.preRender();
+      RBXRenderer.addInstance(rootInstance, new Authentication(), this);
+    }
+    for (const renderedInstance of allRenderedInstances) {
+      if (this.renderDescs.get(renderedInstance) instanceof EmitterGroupDesc) {
+        RBXRenderer.removeInstance(renderedInstance, this);
+      }
+    }
     return new Promise((resolve, reject) => {
       const exporter = new GLTFExporter();
       exporter.parse(this.scene, (gltf) => {
@@ -50603,6 +52099,9 @@ class RBXRendererScene {
         resolve(gltf);
       }, (error2) => {
         reject(error2);
+      }, {
+        animations: clips,
+        binary: actualOptions.binary
       });
     });
   }
@@ -51060,6 +52559,14 @@ class RBXRenderer {
       RBXRenderer.removeInstance(child, renderScene);
     }
   }
+  static getRenderDescs(instance) {
+    const renderDescs = [];
+    for (const renderScene of RBXRenderer.scenes) {
+      const renderDesc = renderScene.renderDescs.get(instance);
+      if (renderDesc) renderDescs.push(renderDesc);
+    }
+    return renderDescs;
+  }
   static _addRenderDesc(instance, auth, DescClass, renderScene) {
     if (!RBXRenderer.renderer) return;
     const oldDesc = renderScene.renderDescs.get(instance);
@@ -51772,7 +53279,7 @@ async function renderTargetToCanvas(renderTarget) {
   await rbxRenderer.readRenderTargetPixelsAsync(renderTarget, 0, 0, width, height, data);
   return imageDataToCanvas(data, width, height);
 }
-async function generateModelThumbnail(auth, renderScene, model, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false) {
+async function generateModelThumbnail(auth, renderScene, model, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false, includeAnimations = false) {
   return new Promise((resolve) => {
     const cameraCFrame = getThumbnailCameraCFrame(model);
     if (cameraCFrame) {
@@ -51791,11 +53298,14 @@ async function generateModelThumbnail(auth, renderScene, model, size = [150, 150
     });
     async function doExport() {
       onLoadingConnection.Disconnect();
-      if (type === "gltf") {
+      if (type === "gltf" || type === "glb") {
         if (!FLAGS.RENDERTARGET_TO_CANVASTEXTURE && FLAGS.USE_RENDERTARGET) {
           warn(true, "FLAGS.RENDERTARGET_TO_CANVASTEXTURE is false, GLTF export cannot export render target textures, consider setting this flag to true");
         }
-        resolve(await renderScene.exportGLTF(`result`, gltfAutoDownload));
+        resolve(await renderScene.exportGLTF(`result`, gltfAutoDownload, {
+          includeAnimations,
+          binary: type === "glb"
+        }));
       } else {
         const renderTarget = renderToRenderTarget(...size, renderScene);
         const canvasTarget = await renderTargetToCanvas(renderTarget);
@@ -51809,7 +53319,7 @@ async function generateModelThumbnail(auth, renderScene, model, size = [150, 150
     }
   });
 }
-async function generateOutfitThumbnail(auth, outfit, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false) {
+async function generateOutfitThumbnail(auth, outfit, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false, includeAnimations = false) {
   return new Promise((resolve) => {
     const startTime = performance.now();
     const renderScene = RBXRenderer.addScene();
@@ -51849,7 +53359,7 @@ async function generateOutfitThumbnail(auth, outfit, size = [150, 150], type = "
       onLoadingConnection.Disconnect();
       if (outfitRenderer.currentRig) {
         outfitRenderer.animateOnce(!outfit.containsAssetType("Gear") && outfit.playerAvatarType === AvatarType.R6 ? 0 : 1);
-        const thumbnailResult = await generateModelThumbnail(auth, renderScene, outfitRenderer.currentRig, size, type, quality, gltfAutoDownload);
+        const thumbnailResult = await generateModelThumbnail(auth, renderScene, outfitRenderer.currentRig, size, type, quality, gltfAutoDownload, includeAnimations);
         console.log("Generated outfit thumbnail after seconds:", (performance.now() - startTime) / 1e3);
         resolve(thumbnailResult);
         if (outfitRenderer.currentRig) outfitRenderer.currentRig.Destroy();
@@ -51934,6 +53444,7 @@ export {
   CACHE,
   CFrame,
   COREMESH,
+  Cache,
   CatalogBundleTypes,
   CategoryDictionary,
   Color3,